Step 3Convince Your Boss
Now, show your boss that Typesafe can deliver the goods. These topics should help.
Now, show your boss that Typesafe can deliver the goods. These topics should help.
You’ve done it - you’ve built a small project and managed to convince your peers that the Typesafe Reactive Platform is the way that you can solve problems related to scalability, accelerating the productivity of your team and building modern, high quality applications. Everyone is excited to start programming with the beauty of Scala, Akka and Play. Only one thing left to do - convince the boss.
Adoption of any new technology is challenging. There are a number of factors that need to be carefully taken into account and managed properly to ensure that the costs of adoption end up being lower than the cost of non-adoption. There are five topics that tend to be top of mind for managers and business leaders when assessing the adoption of Scala versus either other technologies or the maintenance of existing frameworks and libraries.
Training staff on new technology or recruiting experts is a cost that doesn’t exist when a corporation sticks to their existing technologies. As such, it’s important that the impact of the adoption of the Typesafe Reactive Platform is emphasized in any discussion of creating a Scala team. Developers working in the Typesafe Reactive Platform will be able to create higher quality software more quickly that scales better than legacy platforms.
In order to create a Scala team, there are two options - recruit or train. With the popularity of Scala exploding, recruiting developers with more than a year’s worth of production Scala experience can be challenging and it is generally not cost effective or possible to staff an entire Scala team using recruitment alone. A combination of targeted recruitment and a well structured onboarding including training, mentorship and support provides the strongest path to success.
Dianne Marsh, Director of Engineering for Cloud Tools at Netflix and co-author of Atomic Scala, explores best practices for learning Scala in this 30-minute introductory video.Watch The Video
Scala school started as a series of lectures at Twitter to prepare experienced engineers to be productive Scala programmers. This is the written material that accompanied those lectures, which Twitter has found useful in their own right.Read The Community Story
Hiring experienced Scala developers can be challenging. BoldRadius walks through the options they've used to bring on top talent.Learn About Hiring Developers
Training a Scala team, if done in a structured and focused way, should not be overly onerous and there are a lot of resources available. Typesafe offers a series of 2-day corporate training options and Typesafe partners extend this to include practical, hands-on practice in the technologies along with mentorship. Once training is complete, the Typesafe Subscription provides developers with support to ensure that they don’t get hung up with framework issues.
Twitter created a living document on GitHub to reflect its current “best practices” around core ideals: Always favor readability; write generic code but not at the expense of clarity; take advantage of simple language features that afford great power but avoid the esoteric ones (especially in the type system). This guide attempts to distill their experience into short essays, providing a set of best practices that might be useful for your newbies.Read the developer best practice
Workday has been using Scala for a couple of years now. The availability of engineers with Scala experience is getting better. Most of the time, however, they are building their team by helping experienced Java developers become Scala developers. You can learn more about their approach on GitHub.Read the developer best practice
Mike Kelland, BoldRadius CEO, describes his five top tips for how to onboard new scala developers.Read the Tips
Hiren Hiranandani, Senior Scala Trainer at BoldRadius walks through how they approach Scala training and some of the idiosyncrasies involved in training ScalaRead the Approach
Executed correctly, and with the help of a Typesafe partner, an experienced developer can be brought up to competency with Scala in about 2 weeks. Since Scala is so flexible and powerful, self learning can extend the learning curve significantly and impact the ability of the organization to fully realize the benefits of adopting the Typesafe Reactive Platform. Scala’s flexibility can be a challenge in self-led learning as inconsistencies can creep into the corporate code base.
In this use-case presentation, Sr. Architect Devin Ben-Hur addresses questions such as: How and why did we choose Scala? How did we go about training the team on the new language and technology stack? What has the adoption experience been for an engineering team rooted in dynamic languages?View the presentation
Below is suggested Scala reading to help stimulate a self-learning environment for your team:
Bruce and Dianne observed that it would be possible to teach Scala to a beginning programmer and, if they did things right, it would actually be an easier language to learn than Java. The goal of this book is to bridge the gap between the beginner books—either beginning programmer, or just Scala beginner with experience in another language—and the rest of the books out there. If Bruce and Dianne can get you past this first set of hurdles, then you’ll be ready for the next step, probably Cay Horstman's, Scala for the Impatient.Download the free e-book
Every concept and technique in Scala for the Impatient is presented in "blog-size" chunks that can be digested quickly and reviewed as needed for specific tasks. Horstmann offers hands-on activities that guide readers through four well-defined stages of competency: basic, intermediate, advanced and expertDownload the free E-Book
This is a unique book designed to help you integrate Scala effectively into your development process. By presenting the emerging best practices and designs from the Scala community, it guides you through dozens of powerful techniques example by example. There's little heavy-handed theory here—just dozens of crisp, practical techniques for coding in Scala. Written for readers who know Java, Scala, or another OO language.Download the free E-Book
When making an investment in new technology, organizations need to be sure that the technology has the longevity to return that investment. In addition, enterprises need to ensure that their technology choices are proven and stable before they adopt. Enterprise software typically has a 10-year or longer lifetime and the technology base that it is built on needs to match.
Scala’s design was started in 2001 and the first release was in 2003. The versions are stable and it is being used in a wide variety of large-scale, mission critical systems, most notably in the financial, media and social media sectors. Scala is also enjoying a meteoric rise in popularity from below 50th rank on the TIOBE programming language rankings in 2012 to 31st in 2013 and up to 14th in the RedMonk Language Popularity Rankings.
One of the best indicators of Scala’s increasing popularity is that many of the new features included in the upcoming Java 8 release have been inspired by Scala. While the Java 8 implementations are generally simplified and do not provide the same power and benefits of the Scala implementations, the adoption of those kinds of features supports the notion that Scala’s time has come.
People often ask me if lambdas coming to Java will slow the adoption of Scala. Quite the opposite! Instead, I feel the acceptance of these features by the Java Community Process validates our innovation in language design on the JVM. As developers come to understand what these features are and how they work, they will also develop a better appreciation of the more extensive support of functional programming that Scala provides.Read The Article
Scala and the Typesafe Reactive Platform have been enjoying rapid adoption in large part due to recent evolutions in hardware. Hardware is becoming increasingly parallel, with a deep focus on increasing the aggregate multi-threaded performance of systems rather than increasing the speed of a single thread. As such, traditional server approaches that provide developers with a single threaded abstraction and multiplex requests at the process level are becoming less and less efficient. The Typesafe Reactive Platform allows developers to more easily create applications that have built-in multi-threading capabilities and that can fully leverage these new hardware designs.
Scala's appealing fusion of the object-oriented and functional programming paradigms has brought it a substantial following since its introduction in 2003. Scala has demonstrated that you can have the benefits of compile-time static typing -- with a very powerful type system -- while preserving the "rapid application development" aspects and productivity usually associated with dynamically typed languages. Featuring excellent support for concurrent programming using the Actor model, as well as terrific supporting libraries and frameworks like Akka and Play, Scala is poised to be a major mainstream player for decades to come.Read The Article
Adoption of Scala is low risk due to the stability and history of the platform and language, the fact that it runs on the JVM and the rising popularity of functional programming as evidenced by its incorporation in Java 8 and its alignment with modern hardware design.
"There was a level of trust that we all had in the JVM. We were confident we could pull off a sea change for Twitter in the world of the JVM. We estimated that rewriting our codebase [in Scala] could get us > 10x performance." Raffi Krikorian, VP, Platform Engineering, TwitterRead the community story
As organizations build systems to run their businesses, there is a corresponding build up of infrastructure to support those systems. This includes things like server infrastructure, monitoring systems, logging systems, development tools, debugging and performance management tools.
Scala, unlike many new technologies, has the advantage of running on the JVM and easily integrating with existing JVM infrastructure. Developers comfortable with IntelliJ IDEA or Eclipse need only install a plugin to start working with full syntax highlighting in Scala. Existing libraries and code bases built in Java can be directly used and integrated into new Scala projects. Performance and monitoring tools that work with at the JVM level will work with Scala based systems and some, such as New Relic, have specific Scala integration.
In general, any team currently using Java can switch to Scala development with minimal impact on tools and infrastructure.
As hardware becomes increasingly focused on multi-threaded performance and software increasingly centralized for larger and larger numbers of users, there is a growing need for software designers to build multi-threaded and high performance systems. Scala, Play and Akka all handle this challenge in specific ways that will increasingly become the norm for prudent application design.
Over the course of a few seconds, Gilt’s traffic can increase by as much as 100x. Essentially, they need to have the e-commerce infrastructure almost at Amazon scale for at least 15 minutes every day.Read The Article
Play’s built-in use of the Netty framework and unique push/pull model of thread management allows the framework to intelligently use threads. Play can accept a web connection on one thread, maintain the connection, drop the thread when there is a long-running process such as a database request and allocate a new thread to service the request when the process returns.
Akka is built for scalability and provides applications with a distributed-by-design and isolation of functionality using the actor model. Akka provides the ability to create large scale, distributed systems with built in failure management through a supervisor hierarchies and lends itself well to highly concurrent applications where responsiveness, resiliency, and scalability are critical.
Scala’s immutable-first design is expressly built to enable developers to build applications that are safely multi-threaded. With immutable data structures, it is impossible to create race conditions. This makes it much safer to create code that is multi-threaded and can take advantage of the hardware.
Scala, Akka and Play provide strong benefits in terms of developer productivity. The Scala language, in particular, requires far less boilerplate and lines of code than a typical Java application performing the same function. This terseness can reduce code base sizes by over 50%.
There have also been studies that have shown that dense code, in the Scala style, are easier to understand. Scala puts more of the logic on one page of text, providing developers with the ability to more easily reason about the effect of the code in front of them. Well designed Scala also makes more use of functional code with fewer side-effects, providing developers with more opportunity for safe reuse of code segments.
The research paper of Gilles Dubochet at EPFL reports, on average, it is 30% faster to comprehend algorithms that use for-comprehensions and maps, as in Scala, rather than those with the iterative while-loops of Java.Read the Report
The survey created by Graham Lea regarding the perceived productivity gains of Scala developers shows that Java programmers who learn Scala generally feel more productive pretty much straight away.Read the Report
The Play Framework provides strong productivity enhancements over traditional compiled web frameworks like J2EE or .NET. Its RESTful, MVC-focused architecture means that generating a web application with persistence is extremely rapid. In addition, its “just refresh” style of development is reminiscent of dynamic languages such as Ruby, PHP and Python while still offering the performance and maintainability benefits of compiled code.
Akka is an asynchronous event-driven middleware for building high performance and reliable distributed applications. Akka decouples business logic from low-level mechanisms such as threads, locks and non-blocking I/O. Java and Scala program logic lives in lightweight Actor objects, which send and receive messages in a reactive fashion. With Akka, you can easily configure how Actors will be created, destroyed, scheduled, and how to deal with failures.