programming languages
Showing 26 out of 26 results
Python Was Crowned Programming Language King of 2020
Python was crowned programming language king of 2020. We asked frequent GOTO speaker and one of Ireland’s most experienced developers Eamonn Boyle why he thought Python was so loved by devs and what might attribute to its growing popularity.
Expert Talk: Managing Complexity in Software
Complexity of software systems sometimes grows beyond control. Left unchecked, it can leave behind bloated applications. Kevlin Henney talks to Hadi Hariri, developer advocate at JetBrains, about how some of the key traits of developers like creativity and problem solving make them prone to innovate more but also over-engineer their code and not choose solutions based on context.
Teaching Kids How to Code with Hedy
Learning to code entails learning both the programming logic and the syntax of the programming language. In most programmes, the initial classes teach C++. When kids learn to program they often use either a visual language like Scratch or a textual language like Python. But it’s not always the best way. Moving from a block- to text-based programming language can be challenging. That’s where Hedy comes in.
Rust in Action
Rust in Action introduces the Rust programming language by exploring numerous systems programming concepts and techniques. You'll be learning Rust by delving into how computers work under the hood. You'll find yourself playing with persistent storage, memory, networking and even tinkering with CPU instructions. The book takes you through using Rust to extend other applications and teaches you tricks to write blindingly fast code. You'll also discover parallel and concurrent programming. Filled to the brim with real-life use cases and scenarios, you'll go beyond the Rust syntax and see what Rust has to offer in real-world use cases. Richard Feldman, author of Elm in Action, goes over the benefits of this multi-paradigm, high-level, general-purpose language together with Tim McNamara, author of Rust in Action.
Rethinking mobile development with the Flutter UI framework
Flutter is Google’s mobile UI framework for crafting high-quality native interfaces on iOS and Android in record time. We'll talk about how Flutter is different from both the native mobile SDKs, and other multi-platform mobile UI frameworks, and show how to get started with Flutter quickly.
From a Big Band Web App to Serverless Bebop
This talk will take a real-world look at what makes serverless so jazzy. Via a case study from Mapbox, we’ll see how to refactor a hard-to-maintain Node Express app into a collection of Lambda functions, and why we'd want to: lower bills, better code, and happier teams.
The Why of Go v2: Brave New World Edition
Come learn about Go through a time-travel historical lens perspective. What limits did we meet at the beginning of the 21st century that Go was developed for? How does Go evolve as a programming language for the next decades of software development? Learn about the challenges all language architects face in the pursuit of simplicity, explore paradigm shifts happening around programming languages, all in an attempt to see what the future holds.
Why I Was Wrong About TypeScript
In 2014, I made a strong argument that TypeScript was destined to be irrelevant and that my company should not use it in any of our projects. Fast forward to 2018 and we use TypeScript for, like, everything we build at Progress, and I am no longer a source of trustworthy information. In this talk we’ll discuss why I was wrong. Specifically, we’ll take a look at why TypeScript succeeded where other compile-to-JavaScript languages like CoffeeScript and Dart have languished, and what that means for future of the technology. Come to learn the basics of TypeScript, and whether TypeScript is a good fit for your next project.
Good ideas that we forgot
Over the years there have been many good ideas in computer science and many stupid ideas. What can we learn from history? Which of the old and forgotten ideas should be brought back to life and re-evaluated? What can we learn from the ideas of the past?
SOLID Elixir
Design is an important part of Software Development, and plays a key role in creating extendible maintainable solutions. There are many design principles traditionally associated with Object Oriented programming, yet in recent years languages such as Elixir have tempted many developers away from traditional OO languages. In the talk we will explore the OO design principles known as "SOLID", and apply them to an Elixir case study. We will discuss whether these principles are useful in the functional world, or whether functional languages need a set of design principles of their own. After attending this talk you will have a practical understanding of some design principles that can be applied to Elixir and the use cases they can help solve.
Rust Async Programming in 2018
Async IO, network programming and microservices have become a popular application of the Rust programming language. This talk will give an introduction into these subjects and highlight why people are choosing Rust over other options. The talk presents specific language features, like the concurrency-aware type system, as well as libraries that have emerged in the ecosystem to make getting started with a new project as easy as possible.
Let’s Get Lazy: Exploring the Real Power of Streams
Efficiency is achieved not just by running things faster, but by avoiding things that shouldn't be done in the first place. Lazy evaluations are a core feature of many functional programming languages. Your code can benefit from lazy evaluations with lambda expressions and, more so, with the power of Streams. In this presentation, we'll start with a discussion of lazy evaluations, with short examples from Haskell and Scala. Then we'll dive into Java to see how we can achieve similar benefits using lambdas and the Stream API.
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 scalable systems is possible if you have got the system architecture right, bit very difficult otherwise. I'll share some examples of my favorite programming languages showing how things should be done, and how they should not be done.
Bash and All That; Why Ancient *NIX Tools Are Still Essential
Why are we still using bash (and derivatives)? Why are make, sed, grep, and so forth at the tips of our fingers? This talk explores the qualities that keep these tools indispensable, after decades of use. How do they solve specific universal problems? How are they being used in new ways? What don't they do well? What should the "ultimate scripting language" look like?
Kubernetes-ize your Java Application
Deploying your Java application in a Kubernetes cluster could feel like Alice in Wonderland. You keep going down the rabbit hole and don’t know how to make that ride comfortable. This no-slide and code-only session will explain how a Java application consisting of different microservices can be deployed in a Kubernetes cluster. Specifically, it will explain the following: * Show a Java application with three microservices * How this application is packaged as a Docker image * Create Kubernetes manifests * How Helm charts are created and hosted in a Helm repository * Test in a local environment such as minikube * Attach debugger (may need to find out if tooling exists in this area) * Install Istio in k8s, show service visibility * Install k8s on AWS * Migrate application from a local cluster to a cluster on the Cloud * Setup deployment pipeline using CodePipeline * Use an Alexa skill to scale the application * Change application, show A/B using Istio
Simplification and Automation in Java: Yesterday, Today and Tomorrow
Rod will discuss how developing Java applications has changed and simplified over the past 15 years, and what may come next around automation and collaboration. What comes after convention over configuration?
Fresh Async With Kotlin
Asynchronous programming is on the rise. Modern software systems are connected and constantly communicating. Programming languages are adding some form of asynchronous programming like async/await. However, Kotlin had taken a fresh approach to this problem with Kotlin Coroutines. In this talk, we’ll study various approaches to asynchronous programming, their evolution, differences and similarities. We’ll see the problem with the traditional async/await approach that is based on futures/promises and how the Kotlin’s solution that is based on concepts of coroutines and continuations is giving us safer and easier programming model.
Why You Need a Software Delivery Machine
Many teams have a clear vision of how they want their software delivery to work. For example, what checks and staging deployments should occur on commits; what approval steps are required before promotion to production; what code needs to be included in new projects and what provisioning should occur on project creation; and what policies matter around license files and security scanning. But it’s hard to realize that vision. Typical challenges include: * Growing proliferation of services, meaning many delivery pipelines that can’t easily be changed as one, and many repositories with dependencies, configuration and usage practices getting dangerously out of date. * Bringing on new developers, due to lack of effective knowledge sharing and lack of automation * Creating new projects without copy/paste, leading to wasted effort and inconsistency * Lack of visibility into the whole elephant. What is deployed where? What is at what version? What is happening across the organization? Who should be informed in the case of a production alert, and to what code does it relate? The solution to these software problems is more software. These problems can best be addressed together, through greater automation, backed by a model spanning development and delivery. It’s what we call a software delivery machine.
Machine Learning: Alchemy for the Modern Computer Scientist
In ancient times, the dream of alchemists was to mutate ordinary metals such as lead into noble metals such as gold. However, by using classic mathematics, modern physicists and chemists are much more successful in understanding and transforming matter than alchemists ever dreamt of. The situation in software seems to be the opposite. Modern computer scientists have been unsuccessful in their quest to reliably turn formal specifications into code and to accurately understand the mechanics of side-effecting computation. On the other hand, software alchemists, by using classic mathematics, have been extremely successful in mutating training data into pure functions using various machine learning techniques, in particular deep learning. Mechanically learning code from training data is often referred to as "Software 2.0" or "Learning-based development". This new paradigm of software creation will require a radical rethinking of the ancestral software engineering and imperative programming practices that have been developed in the second half of the last century. In this talk we will discuss how we are building new probabilistic frameworks and differentiable programming languages that support the composition and construction of learnable code, as well as how we can leverage machine learning at every level of the software stack to make developers more productive and services & products more efficient.
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.
Getting Started with Quantum Programming
A Quantum Computer is a new type of computer that uses quantum mechanics to run certain algorithms exponentially faster than their classical equivalents. These quantum algorithms typically use phenomena such as superposition, the ability for a quantum state to be two different values at once, and entanglement, or the ability for two quantum states to be inherently dependent on each other. Companies such as Google, IBM, Microsoft and start-ups such as Rigetti are investing heavily in this technology, and are deploying quantum processors in the cloud to use by the wider public. In this talk, I will give an introduction to the syntax of quantum programming, and introduce several platforms and quantum programming libraries to help you get started writing your own quantum algorithms. Finally, I will go over some example algorithms and explain how they can be used for practical applications. **Who should attend this talk?** Anyone who is interested in getting started with learning how to program quantum computers. **Academic level** Intermediate (some coding and mathematics knowledge will be helpful) **What is the take away in this talk?** It's easy to get started with quantum programming! Most languages use Python and come with a built-in quantum simulator. Some languages can be run on real hardware prototypes.
Reaching Beyond Traditional Boundaries with Clojure
Clojure and ClojureScript provide fine-grained control over the state of a running application. Especially when combined with a reactive front-end framework like React, features like hot-swapping code reach far beyond simple live reloading. Applying a reactive paradigm means that changing the data updates the user interface. Clojure's functional nature, with its strict separation of data and code, lets us use the reactive paradigm for development as well: changing the code updates the user interface. This works not only in the front end of a development environment. Using this mechanism over a networked REPL provides the same capabilities in the back end of a production environment. In an example-driven approach we will explore several typical situations in software development in which Clojure helps us to speed up not only our development cycle but also DevOps.
Why You Need a Software Delivery Machine
Many teams have a clear vision of how they want their software delivery to work. For example, what checks and staging deployments should occur on commits; what approval steps are required before promotion to production; what code needs to be included in new projects and what provisioning should occur on project creation; and what policies matter around license files and security scanning. But it’s hard to realize that vision. Typical challenges include: * Growing proliferation of services, meaning many delivery pipelines that can’t easily be changed as one, and many repositories with dependencies, configuration and usage practices getting dangerously out of date. * Bringing on new developers, due to lack of effective knowledge sharing and lack of automation * Creating new projects without copy/paste, leading to wasted effort and inconsistency * Lack of visibility into the whole elephant. What is deployed where? What is at what version? What is happening across the organization? Who should be informed in the case of a production alert, and to what code does it relate? The solution to these software problems is more software. These problems can best be addressed together, through greater automation, backed by a model spanning development and delivery. It’s what we call a software delivery machine.
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? 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? Some experiences and thoughts answering these questions will be shared during this live coding session. **What will the audience learn from this talk?** * 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. **Attendees:** <a href="https://goto-m6l1171.slack.com/archives/C01DWRWV2R1" target="_blank">Join the #programming channel on Slack to send your questions to Paulien</a>
Life After Business Objects - Confessions of an OOP Veteran
It finally happened: tired of mutable data structures and thread synchronisation, Vagif's team decided to use functional programming and F# for the next generation of their system. Gigabytes of data are going through their applications every hour with high demand for performance, scalability and failure recovery. The fact that their project has for a long time been in production can identify it as success, but has the choice of FP become an essential part of this success?<br /> Could they achieve similar development speed and operational stability if we settled for OOP (and C# on .NET platform)?<br /> They believe that functional programming provides a set of defaults that can give significant advantages for development with short deadlines and continuous deployment, and Vagif will share their experience and lessons learned in this talk. **Attendees:** <a href="https://goto-m6l1171.slack.com/archives/C01DWRWV2R1" target="_blank">Join the #programming channel on Slack to send your questions to Vagif</a>
