New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Episode 1 #1

Closed
garricn opened this Issue Jan 12, 2019 · 15 comments

Comments

Projects
None yet
@garricn
Copy link
Member

garricn commented Jan 12, 2019

What did you think about Episode 1?

@BasThomas

This comment has been minimized.

Copy link
Contributor

BasThomas commented Jan 16, 2019

Shiny? :)

@charlesism

This comment has been minimized.

Copy link

charlesism commented Jan 16, 2019

The podcast is an excellent idea, and the first episode was an excellent listen. It was interesting hearing Chris discuss the early development of the language.

Since the podcast is just starting, I’m not sure what on which areas future episodes will focus.

Personally, I’d love to hear people in the community weigh in a little on issues that pop up on the evolution board.

Would also be interested in hearing more of Chris’s thoughts on what features are, and are not, working.

Well, I’m subscribed, and look forward to future episodes.

@salutis

This comment has been minimized.

Copy link

salutis commented Jan 16, 2019

Chris talking about the early development of Swift was great. Personally, I would love to see the podcast go deep, e.g. what were some of the controversial topics during those first whiteboard sessions, etc. I'm sure there's a lot of fun stories! Time to geek out. 🤓 Also, Chris needs a better microphone.

@mortenbekditlevsen

This comment has been minimized.

Copy link

mortenbekditlevsen commented Jan 17, 2019

Great idea for a podcast - and an excellent first episode. I hope to be able to contribute at some time! 😊

I would personally love to hear more about all of your wildest dreams for Swift.

I am following most discussions on the forums and have read most manifests and most proposals (I am very much a lurker - and seldom participate in the discussions myself...). I really love thinking about all the interesting ideas about generics and concurrency and any other things that may not be part of the language in the near future.

So for those of us that have a teeny tiny grasp about what variadic generics are - it could be great to learn what having them may mean for tuples and the possibility of extending non-nominal types like tuples. Are these concepts at all connected or am I misunderstanding something? A deep dive into generalized existentials, built-in type erasure, the issues that I think Dave Abrahams listed for why automatic type erasure doesn't always deal with the fundamental issues that some of us think will be automatically fixed if generalized existentials were a thing?

The possibilities for the async/await future (pun intended) and the actor model are also so intriguing to hear about. Specifically about the lifetime of actors and the possibility to specify re-spawn behaviors - and how actors could potentially be concepts that run not only in different threads, but perhaps across different types of hardware (I think Chris mentioned communicating to the GPU over an actor model) and other machines. These topics really blow my mind and I love imagining how it will impact how we code.

Any other thoughts about cross platform challenges, typed throws, async perhaps being a sub type of thowing (right?), current and future string APIs, file APIs, what the differentiability concept of Swift for Tensor Flow actually allows, and whether this is useful in general in swift?

Thoughts about interop with python and other language runtimes?

Any functional concepts and how they fit into Swift would also be interesting. Higher kinded types is something that is often mentioned, but a bit elusive to those of us who are still learning (by listening to the excellent pointfree.co of course).

How guaranteeing that a function is pure could be a language concept and what this could mean for proofs or optimizability of code - if this is a thing at all?

How reflection could be improved from today - and what can you actually do today with the Mirror type? Why (perhaps) it may not make sense to ever allow for getting string representations of keypaths? How some kind of 'attributes' could work with reflection and other tools?

How property behaviors may or may not still be a thing for swifts future, and how having them could perhaps give us tools to model atomic variables and other interesting features?

The current state of Codable and a description of the possible future the Itai Ferber has recently outlined, and how this could benefit from having concepts like attributes and so on?

Any speculations about how Apple may choose to adopt Swift for frameworks?

Speculations about Swift for writing web apps (through web assembly) and speculations about if you could get access to the DOM through web assembly and some nice swift APIs?

Speculations and deep dives into writing Android apps or components using Swift?

Swift has already completely transformed my world of programming. It has completely eliminated huge classes of errors and made it possible and easy to write less error-prone code.

The biggest single thing for me is probably the Optional type. What kinds of ground-shaking ideas like this could we perhaps see in the future?

One of the remaining issues of programming that are currently surfacing in the code that I write is retain cycles - mainly by capturing self in closures bound to the life time of the same 'self'.
Any thoughts about how compiler or tools could help us identifying such situations. Could one imagine function annotations that prove that a callback will always be called exactly once? And then this information could be used to prove that it is always ok to capture self in that closure since the lifetime of the closure is proven to end at some point?

Any other thoughts about the direction that programming language could / should take in the future?

@AustinConlon

This comment has been minimized.

Copy link
Contributor

AustinConlon commented Jan 18, 2019

Any chance Bertrand Serlet could come onto a future episode?

@jonjon1251

This comment has been minimized.

Copy link

jonjon1251 commented Jan 18, 2019

Really great first episode ! I really enjoyed hearing Swifts early beginnings inside Apple. Also how Garric and John got into iOS development. Swift was definitely the first time for me that I felt like a programing language made sense. SwiftPlaygounds helped me get started where a lot of coding books never did the trick as I was starting out. It was really inspirational to hear of other developers that started with Swift because of its accessibility to learn and are now part of the community : ). Looking forward to the next show and where it goes from here.

@renatoDutraSilva

This comment has been minimized.

Copy link

renatoDutraSilva commented Jan 19, 2019

I’ve been reading about swift for some time now, and also learning quite a bit through Apple’s books and online articles such as swiftbysundell. I’m hoping to become better at coding and while I am not much of a valuable contributor in terms of knowledge about the swift language, I can help in almost every other aspect of the podcast. I have quite a bit of experience in audio processing and production and would like to contribute (short music intro for the show for example?)

Can’t wait for the next episode!

@amw-zero

This comment has been minimized.

Copy link

amw-zero commented Jan 19, 2019

It was so cool hearing about the origins of Swift from Chris. What I would really like to dive into more is the opinions on some of the positions that Swift takes, like static typing vs. dynamic typing. Or its inclusion of lots of functional features. Does the team think that this is the best way to develop software? It would be awesome to hear the reasonings why.

It was also so great to hear Chris complement Sundell’s gift of communication. That was really humble, and a great remark about the different skills that people can have. Communication really is a different part of the brain, and it’s a skill that is often undercooked in engineering. Happy to see that called out.

Overall, this is the podcast I’ll be paying attention to most in the coming weeks. Really excited to see where it goes.

@kemchenj

This comment has been minimized.

Copy link

kemchenj commented Jan 20, 2019

In some sense, start from Episode #0 would be more appropriate? 🤓

@garricn

This comment has been minimized.

Copy link
Member Author

garricn commented Jan 21, 2019

Great idea for a podcast - and an excellent first episode. I hope to be able to contribute at some time! 😊

I would personally love to hear more about all of your wildest dreams for Swift.

I am following most discussions on the forums and have read most manifests and most proposals (I am very much a lurker - and seldom participate in the discussions myself...). I really love thinking about all the interesting ideas about generics and concurrency and any other things that may not be part of the language in the near future.

So for those of us that have a teeny tiny grasp about what variadic generics are - it could be great to learn what having them may mean for tuples and the possibility of extending non-nominal types like tuples. Are these concepts at all connected or am I misunderstanding something? A deep dive into generalized existentials, built-in type erasure, the issues that I think Dave Abrahams listed for why automatic type erasure doesn't always deal with the fundamental issues that some of us think will be automatically fixed if generalized existentials were a thing?

The possibilities for the async/await future (pun intended) and the actor model are also so intriguing to hear about. Specifically about the lifetime of actors and the possibility to specify re-spawn behaviors - and how actors could potentially be concepts that run not only in different threads, but perhaps across different types of hardware (I think Chris mentioned communicating to the GPU over an actor model) and other machines. These topics really blow my mind and I love imagining how it will impact how we code.

Any other thoughts about cross platform challenges, typed throws, async perhaps being a sub type of thowing (right?), current and future string APIs, file APIs, what the differentiability concept of Swift for Tensor Flow actually allows, and whether this is useful in general in swift?

Thoughts about interop with python and other language runtimes?

Any functional concepts and how they fit into Swift would also be interesting. Higher kinded types is something that is often mentioned, but a bit elusive to those of us who are still learning (by listening to the excellent pointfree.co of course).

How guaranteeing that a function is pure could be a language concept and what this could mean for proofs or optimizability of code - if this is a thing at all?

How reflection could be improved from today - and what can you actually do today with the Mirror type? Why (perhaps) it may not make sense to ever allow for getting string representations of keypaths? How some kind of 'attributes' could work with reflection and other tools?

How property behaviors may or may not still be a thing for swifts future, and how having them could perhaps give us tools to model atomic variables and other interesting features?

The current state of Codable and a description of the possible future the Itai Ferber has recently outlined, and how this could benefit from having concepts like attributes and so on?

Any speculations about how Apple may choose to adopt Swift for frameworks?

Speculations about Swift for writing web apps (through web assembly) and speculations about if you could get access to the DOM through web assembly and some nice swift APIs?

Speculations and deep dives into writing Android apps or components using Swift?

Swift has already completely transformed my world of programming. It has completely eliminated huge classes of errors and made it possible and easy to write less error-prone code.

The biggest single thing for me is probably the Optional type. What kinds of ground-shaking ideas like this could we perhaps see in the future?

One of the remaining issues of programming that are currently surfacing in the code that I write is retain cycles - mainly by capturing self in closures bound to the life time of the same 'self'.
Any thoughts about how compiler or tools could help us identifying such situations. Could one imagine function annotations that prove that a callback will always be called exactly once? And then this information could be used to prove that it is always ok to capture self in that closure since the lifetime of the closure is proven to end at some point?

Any other thoughts about the direction that programming language could / should take in the future?

Wow! You should be a co-host!

@garricn

This comment has been minimized.

Copy link
Member Author

garricn commented Jan 21, 2019

In some sense, start from Episode #0 would be more appropriate? 🤓

🤣

@ivanglushko

This comment has been minimized.

Copy link

ivanglushko commented Jan 21, 2019

It's hard to judge cause it's 1 episode obviously. Was nice hearing the stories how did you meet and etc. It's awesome that you are such different developers with different backgrounds. I'd wanted to hear the reasons behind some proposals or implementations in swift. And from Garric I'd wanted to give us a view from a beginner's perspective on some topics that may come out as hard.

@mortenbekditlevsen

This comment has been minimized.

Copy link

mortenbekditlevsen commented Jan 22, 2019

Great idea for a podcast - and an excellent first episode. I hope to be able to contribute at some time! 😊
I would personally love to hear more about all of your wildest dreams for Swift.
I am following most discussions on the forums and have read most manifests and most proposals (I am very much a lurker - and seldom participate in the discussions myself...). I really love thinking about all the interesting ideas about generics and concurrency and any other things that may not be part of the language in the near future.
So for those of us that have a teeny tiny grasp about what variadic generics are - it could be great to learn what having them may mean for tuples and the possibility of extending non-nominal types like tuples. Are these concepts at all connected or am I misunderstanding something? A deep dive into generalized existentials, built-in type erasure, the issues that I think Dave Abrahams listed for why automatic type erasure doesn't always deal with the fundamental issues that some of us think will be automatically fixed if generalized existentials were a thing?
The possibilities for the async/await future (pun intended) and the actor model are also so intriguing to hear about. Specifically about the lifetime of actors and the possibility to specify re-spawn behaviors - and how actors could potentially be concepts that run not only in different threads, but perhaps across different types of hardware (I think Chris mentioned communicating to the GPU over an actor model) and other machines. These topics really blow my mind and I love imagining how it will impact how we code.
Any other thoughts about cross platform challenges, typed throws, async perhaps being a sub type of thowing (right?), current and future string APIs, file APIs, what the differentiability concept of Swift for Tensor Flow actually allows, and whether this is useful in general in swift?
Thoughts about interop with python and other language runtimes?
Any functional concepts and how they fit into Swift would also be interesting. Higher kinded types is something that is often mentioned, but a bit elusive to those of us who are still learning (by listening to the excellent pointfree.co of course).
How guaranteeing that a function is pure could be a language concept and what this could mean for proofs or optimizability of code - if this is a thing at all?
How reflection could be improved from today - and what can you actually do today with the Mirror type? Why (perhaps) it may not make sense to ever allow for getting string representations of keypaths? How some kind of 'attributes' could work with reflection and other tools?
How property behaviors may or may not still be a thing for swifts future, and how having them could perhaps give us tools to model atomic variables and other interesting features?
The current state of Codable and a description of the possible future the Itai Ferber has recently outlined, and how this could benefit from having concepts like attributes and so on?
Any speculations about how Apple may choose to adopt Swift for frameworks?
Speculations about Swift for writing web apps (through web assembly) and speculations about if you could get access to the DOM through web assembly and some nice swift APIs?
Speculations and deep dives into writing Android apps or components using Swift?
Swift has already completely transformed my world of programming. It has completely eliminated huge classes of errors and made it possible and easy to write less error-prone code.
The biggest single thing for me is probably the Optional type. What kinds of ground-shaking ideas like this could we perhaps see in the future?
One of the remaining issues of programming that are currently surfacing in the code that I write is retain cycles - mainly by capturing self in closures bound to the life time of the same 'self'.
Any thoughts about how compiler or tools could help us identifying such situations. Could one imagine function annotations that prove that a callback will always be called exactly once? And then this information could be used to prove that it is always ok to capture self in that closure since the lifetime of the closure is proven to end at some point?
Any other thoughts about the direction that programming language could / should take in the future?

Wow! You should be a co-host!

Woah - are you being serious? :-)
And do you mean like a guest on an episode?

I must warn that I am a bit introvert and shy, but it is part of my New Year's resolution to be more active in the community rather than just lurking and adding the occational comment in the forums...

@garricn

This comment has been minimized.

Copy link
Member Author

garricn commented Jan 25, 2019

Great idea for a podcast - and an excellent first episode. I hope to be able to contribute at some time! 😊
I would personally love to hear more about all of your wildest dreams for Swift.
I am following most discussions on the forums and have read most manifests and most proposals (I am very much a lurker - and seldom participate in the discussions myself...). I really love thinking about all the interesting ideas about generics and concurrency and any other things that may not be part of the language in the near future.
So for those of us that have a teeny tiny grasp about what variadic generics are - it could be great to learn what having them may mean for tuples and the possibility of extending non-nominal types like tuples. Are these concepts at all connected or am I misunderstanding something? A deep dive into generalized existentials, built-in type erasure, the issues that I think Dave Abrahams listed for why automatic type erasure doesn't always deal with the fundamental issues that some of us think will be automatically fixed if generalized existentials were a thing?
The possibilities for the async/await future (pun intended) and the actor model are also so intriguing to hear about. Specifically about the lifetime of actors and the possibility to specify re-spawn behaviors - and how actors could potentially be concepts that run not only in different threads, but perhaps across different types of hardware (I think Chris mentioned communicating to the GPU over an actor model) and other machines. These topics really blow my mind and I love imagining how it will impact how we code.
Any other thoughts about cross platform challenges, typed throws, async perhaps being a sub type of thowing (right?), current and future string APIs, file APIs, what the differentiability concept of Swift for Tensor Flow actually allows, and whether this is useful in general in swift?
Thoughts about interop with python and other language runtimes?
Any functional concepts and how they fit into Swift would also be interesting. Higher kinded types is something that is often mentioned, but a bit elusive to those of us who are still learning (by listening to the excellent pointfree.co of course).
How guaranteeing that a function is pure could be a language concept and what this could mean for proofs or optimizability of code - if this is a thing at all?
How reflection could be improved from today - and what can you actually do today with the Mirror type? Why (perhaps) it may not make sense to ever allow for getting string representations of keypaths? How some kind of 'attributes' could work with reflection and other tools?
How property behaviors may or may not still be a thing for swifts future, and how having them could perhaps give us tools to model atomic variables and other interesting features?
The current state of Codable and a description of the possible future the Itai Ferber has recently outlined, and how this could benefit from having concepts like attributes and so on?
Any speculations about how Apple may choose to adopt Swift for frameworks?
Speculations about Swift for writing web apps (through web assembly) and speculations about if you could get access to the DOM through web assembly and some nice swift APIs?
Speculations and deep dives into writing Android apps or components using Swift?
Swift has already completely transformed my world of programming. It has completely eliminated huge classes of errors and made it possible and easy to write less error-prone code.
The biggest single thing for me is probably the Optional type. What kinds of ground-shaking ideas like this could we perhaps see in the future?
One of the remaining issues of programming that are currently surfacing in the code that I write is retain cycles - mainly by capturing self in closures bound to the life time of the same 'self'.
Any thoughts about how compiler or tools could help us identifying such situations. Could one imagine function annotations that prove that a callback will always be called exactly once? And then this information could be used to prove that it is always ok to capture self in that closure since the lifetime of the closure is proven to end at some point?
Any other thoughts about the direction that programming language could / should take in the future?

Wow! You should be a co-host!

Woah - are you being serious? :-)
And do you mean like a guest on an episode?

I must warn that I am a bit introvert and shy, but it is part of my New Year's resolution to be more active in the community rather than just lurking and adding the occational comment in the forums...

I’m being 100% serious. This is an open source community driven show where anyone should feel empowered to produce an episode and even be the lead host! We’re currently testing out an Episode Proposal Process. Check out #18 #19 and #22 for details and feel free to propose an episode as outlined in those PRs

@marcusrossel

This comment has been minimized.

Copy link
Contributor

marcusrossel commented Feb 9, 2019

@garricn Should this issue be closed as it is not immediately relevant anymore? (I'm assuming closed issues remain visible on GitHub?)

@BasThomas BasThomas closed this Feb 11, 2019

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment