languages
Showing 16 out of 16 results
Functional Programming Through the Lens of a Philosopher and Linguist
If you think functional programming isn't for you, think again and read on... Anjana Vakil will show you what foreign languages, computational linguistics and the way humans express themselves all have in common. She'll also explore how you can declutter your programming and learn new things.
Should Kotlin Be Your Go-To Language?
In the ever-changing landscape of programming, Eammon Boyle and Garth Gilmour have chosen Kotlin as their default language. Preben Thorø explores the reasons behind that choice and how this language could make your life easier.
The Do's and Don'ts of Error Handling
Handling errors in programs is tricky. We want to write systems that work reasonable well even if there are errors in the code. This is possible, and the results have been used in production systems for many years. This talk outlines the do's and don'ts of error handling. Things you should do if you want to write fault tolerant code, and things you should not do. I will argue that making fault-tolerant and salable systems is possible if you have got the system architecture right, bit very difficult otherwise. I'll give examples some of my favorite programming languages of how things should be done, and how they should not be done.
Cloud Native Java
To rapidly deliver web applications to production, organizations are turning to infrastructure automation provided by a cloud platform, like Cloud Foundry or Kubernetes. With a cloud platform in place, every team will have what they need to create a CI/CD pipeline that safely delivers applications to a production environment. The final ingredient for success is knowing the right patterns for connecting distributed applications together over HTTP using REST APIs. In this session, Kenny Bastani from Pivotal will dive into a reference architecture that demonstrates the patterns and practices for securely connecting together cloud native Java applications.
Rapid Java Innovation
Java 10 is here and with it the era of more rapid innovation in the language, libraries, and the JVM. Even better, Java 11 is well on its way and will be coming in September! Learn about how the rapid cadence affects you, how to find out what is coming, and how to try out the latest. Hear what areas of research are active, how these fit together, and how you can take part in their development and/or give feedback to help shape their progress. This is not your grandparent’s Java!
Old Is the New New
Everything is changing. Everything is new. Frameworks, platforms and trends are displaced on a weekly basis. Skills are churning. And yet... Beneath this seemingly turbulent flow there is a slow current, strong and steady, changing relatively little over the decades. Concepts with a long history appear in new forms and fads and technologies. Principles are revisited. Ideas once lost to the mainstream are found again. In this keynote we revisit the present through the past, looking at the enduring principles that shape programming languages, architecture, development practice and development process, the ideas that cycle round, each time becoming perhaps a little better defined, a little more mature, and look to see what else might be on the horizon.
Learning to Live with Errors
Annotation: If trials of three or four simple cases have been made, and are found to agree with the results given by the engine, it is scarcely possible that there can be any error. (On the mathematical powers of the calculating engine, Charles Babbage, 1837) If Charles Babbage was right, you would just try to run your program on three or four sample inputs and be sure that it will work correctly. Sadly, the world is not so simple. Since the invention of electronic computers, we mostly eliminated hardware issues, but software errors remain. And programmers spent over 60 years finding different strategies for dealing with coding errors. In this talk, I look at five strategies for dealing with errors that appeared throughout the history of programming. Understanding the origins of different approaches to errors is not just a fun historical exploration, but it sheds light on current issues in programming, including computer science education, hiring process and the never-ending programming language wars.
Software Automation in a Polyglot Stack
I spent years as a Java developer, then years gobbling up languages like Scala, F#, Clojure, Elm, and Ruby. Some days I long for the simplicity of one language. How can we have the best of both worlds: flexibility and exploration, without the productivity hit? Jessitron has an answer (hint: it involves even more code).
Let Kotlin Come To You
Kotlin is a statically typed, multi-platform language, developed by JetBrains. It’s use has increased dramatically in the past year. What does the language offer us, and why might we choose it? In this talk we’ll go over some of the basics of Kotlin, the benefits, and how we can use it in our day to day development. You will walk away from this talk with the tools you need to get started learning and building with Kotlin, whether you’re working with the JVM, JavaScript, or native.
The Robustness of Go
Go was designed with Google's needs in mind, and when you're running software at the scale that Google does robustness is of prime importance. In this talk we will cover what design decisions of Go help building robust programs, but also those parts of the language can cause problems that one needs to be aware and what techniques to apply to avoid risks. We will also compare Go robustness to Erlang, probably the most robust runtime out there, and see how its "let it crash" principle can be brought into Go.
Analyzing Pwned Passwords with Apache Spark
Apache Spark aims to solve the problem of working with large scale distributed data -- and with access to over 500 million leaked passwords we have a lot of data to dig through. Advancements in the API make running Spark with Scala, Python, or even SQL smoother and faster than ever. This talk will introduce you to Spark and the new way to run queries on structured, distributed data by looking at breached credentials. We'll walk through how to get started with Spark and discuss the tradeoffs for using different abstractions provided by the framework. With the help of live code, we'll find patterns in the password data and look at how you can encourage your users to be more secure. You will see how easy and fast it is to both explore and process data using Spark SQL and leave with the tools to get started with your own distributed data...and a password manager.
C++ - the Newest Old Language
C++ is an old language only used by the unfortunate few that absolutely have to, right? Wrong! C++ is not the language it used to be: clunky, error-prone and lacking in tooling. A lot has changed in the last decade: three new language revisions, new compilers and all-new tooling and diagnostics. Memory leaks and segmentation faults are all but a distant memory! In this talk, Matt will cover some of the things that make C++ a great choice for a wide variety of applications. He'll cover the best of the new bits of the language, and demonstrate how modern tooling makes coding in C++ fun again. The intended audience is both C++ folks who might want to catch up on the latest and greatest, but also anyone who think C++ is a write-off and isn't used any more.
Making It Count: Quality is NOT an Option
All too often quality comes along as an afterthought to the software systems we build. Sometimes quality is not even a concern at all. However, increasingly our systems have to be right the first time. Software is hard to design and implement. Let alone design and implement well. What can we do to be better at designing and delivering better software and systems? Does language choice, such as Java vs. C++ vs. C vs. Erlang really matter in terms of producing quality software? Can you actually produce quality systems on budget and on time? In this session, we will discuss lessons learned from almost a decade of working on NASA software projects that had to work correctly or people could die. And how these lessons continue to impact the speakers mindset and outlook on a daily basis.
Keeping Up with Java
It seems like keeping up with Java nowadays is an enormous task. Gone is the era of big, delayed Java releases that take many years. We’re now getting a new major release every 6 months. What’s up with that? You’re probably still developing on Java 8, even though Java 12 is already available. Join this session to get an overview of what’s new in Java since Java 8. We’ll give an overview of the module system and other new features in Java 9, the local-variable type inference feature (`var` in Java 10), and the new HttpClient API (Java 11). Expect lots of advice on how to get from Java 8 to Java 11 and beyond. It’s time to embrace the newfound agility of the Java platform! **What will the audience learn from this talk?**<br> How (and why) you should move from the ubiquitous but old Java 8 to Java 11 and beyond. **Does it feature code examples and/or live coding?**<br> The session features a combination of slides, code examples and live-coding **Prerequisite attendee experience level:** <br> [Level 200](https://gotoams.nl/2019/pages/experience-level)
Rust 2018: Access All Areas
2018 has seen a massive push towards improving Rusts usability. This comes both with ergonomics improvements, but also with stabilisation of a lot of use-case specific features. Rust is now usable and is used on everything from bare metal microcontrollers over small IoT gateway systems up to server programming. It can be deployed on phones just as it can be deployed in your web browser through Webassembly (WASM). That makes the newest edition of Rust the only currently available memory-safe language that can be used in almost any contexts without the need of a runtime. This talk gives you a tour of what is possible with just one language and just one compiler right now. Finally, Rust 2018 includes a lot of ergonomics improvements like a better async/await-story and cleverer safety checking to make your stay great. **What will the audience learn from this talk?**<br> This talk will teach you a couple not immediately visible aspects of the Rust programming language, especially around platform support. It will also allow you to follow the reasoning of others who evaluated and picked the language. **Does it feature code examples and/or live coding?**<br> Yes, there will be code samples. **Prerequisite attendee experience level:** <br> [Level 100](https://gotoams.nl/2019/pages/experience-level)
Upgrade Time: Choose Java 11 or the “other” one… Kotlin
Most of the Java applications are written in Java 8 nowadays and people are looking around to upgrade to Java 11 or even migrating to Kotlin. Both are promoted as the new way to go and both have their own strengths and weaknesses. Upgrading to Java 11 might be an obvious next safe step to do. But what if you could migrate to Kotlin with the same effort?<br /> This would bring you additional advantages like: data classes, very concise list manipulations, extension functions, DSL's and even more to get your code more readable and maintainable. Considering the Kotlin migration, the first questions that pop up are: What are the wise steps to take? And where to start?<br /> Some experiences and thoughts answering these questions will be shared during this live coding session. **What will the audience learn from this talk?**<br> - how to migrate a Java service to Kotlin in concrete and independent steps - the difference in idioms between the two languages - how to use Kotlin in an idiomatic way Finally the audience will have a complete view on how to migrate successfully. **Does it feature code examples and/or live coding?**<br> yes **Prerequisite attendee experience level:** <br> [Level 300](https://gotoams.nl/2019/pages/experience-level)
