This document discusses Patric Fornasier's experience over 3 years using Scala at Springer, an academic publisher. While Scala increased productivity initially and attracted engineers, complexity issues emerged over time like slow compilation, poor tooling, and entanglements from traits. To address these, the team reduced code size, traits usage, and complexity. In the future, the team may use Java 8 for new projects and embrace polyglotism for smaller teams due to Scala's challenges with complexity and tooling.
Scala is a programming language that mixes object oriented and functional programming in a powerful and flexible way. While it can not be considered as a mainstream language, it has seen a growing adoption trend.An important ingredient for this diffusion is its complete interoperability with Java and the fact that it runs on a solid platform such as the JVM.
It is currently the 4th most loved programming language and the 2nd top paying technology of 2016 (StackOverflow Developers Survey).
These slides have been used for a 4h seminar at the University of Cagliari the 17th of December 2016
LSUG: How we (mostly) moved from Java to ScalaGraham Tackley
Presentation from talk done at the London Scala User Group on Wednesday 12th Jan 2011.
http://skillsmatter.com/podcast/java-jee/how-we-mostly-moved-from-java-to-scala
Scala is a programming language that mixes object oriented and functional programming in a powerful and flexible way. While it can not be considered as a mainstream language, it has seen a growing adoption trend.An important ingredient for this diffusion is its complete interoperability with Java and the fact that it runs on a solid platform such as the JVM.
It is currently the 4th most loved programming language and the 2nd top paying technology of 2016 (StackOverflow Developers Survey).
These slides have been used for a 4h seminar at the University of Cagliari the 17th of December 2016
LSUG: How we (mostly) moved from Java to ScalaGraham Tackley
Presentation from talk done at the London Scala User Group on Wednesday 12th Jan 2011.
http://skillsmatter.com/podcast/java-jee/how-we-mostly-moved-from-java-to-scala
This is brief presentation on the Scala programming language. It is aimed at Java developers who are curious about Scala. It was given at a San Francisco Java User Group in January 2009.
Slides from my talk at the Feb 2011 Seattle Tech Startups meeting. More info here (along with powerpoint slides): http://www.startupmonkeys.com/2011/02/scala-frugal-mechanic/
Slides for my recent presentation at the CASE meetup, May 21st. Discusses functional programming features in Scala. Goes from basic FP features like higher-order functions all the way through to monads.
The workshop aims to introduce Scala > 2.10 and was held at Clueda AG .
It gives an introduction to Scala also explaining widely used language features like case classes, patten matching, futures and string interpolation.
Weaving Dataflows with Silk - ScalaMatsuri 2014, TokyoTaro L. Saito
Silk is a framework for building dataflows in Scala. In Silk users write data processing code with collection operators (e.g., map, filter, reduce, join, etc.). Silk uses Scala Macros to construct a DAG of dataflows, nodes of which are annotated with variable names in the program. By using these variable names as markers in the DAG, Silk can support interruption and resume of dataflows and querying the intermediate data. By separating dataflow descriptions from its computation, Silk enables us to switch executors, called weavers, for in-memory or cluster computing without modifying the code. In this talk, we will show how Silk helps you run data-processing pipelines as you write the code.
Introduction to Kotlin Language and its application to Android platformEastBanc Tachnologies
Author: Oleg Godovykh, eastbanctech.com
Kotlin is a new programming language built by Jetbrains and is a new member of JVM family. As opposed to typical reason to introduce some new language, Kotlin main goal isn't to create new paradigm or fill a new niche, but to make routine tasks much easier and safer. Kotlin gains popularity across Android developer community, and in this presentation it is shown how Kotlin usage can dramatically simplify typical mobile app development.
This is brief presentation on the Scala programming language. It is aimed at Java developers who are curious about Scala. It was given at a San Francisco Java User Group in January 2009.
Slides from my talk at the Feb 2011 Seattle Tech Startups meeting. More info here (along with powerpoint slides): http://www.startupmonkeys.com/2011/02/scala-frugal-mechanic/
Slides for my recent presentation at the CASE meetup, May 21st. Discusses functional programming features in Scala. Goes from basic FP features like higher-order functions all the way through to monads.
The workshop aims to introduce Scala > 2.10 and was held at Clueda AG .
It gives an introduction to Scala also explaining widely used language features like case classes, patten matching, futures and string interpolation.
Weaving Dataflows with Silk - ScalaMatsuri 2014, TokyoTaro L. Saito
Silk is a framework for building dataflows in Scala. In Silk users write data processing code with collection operators (e.g., map, filter, reduce, join, etc.). Silk uses Scala Macros to construct a DAG of dataflows, nodes of which are annotated with variable names in the program. By using these variable names as markers in the DAG, Silk can support interruption and resume of dataflows and querying the intermediate data. By separating dataflow descriptions from its computation, Silk enables us to switch executors, called weavers, for in-memory or cluster computing without modifying the code. In this talk, we will show how Silk helps you run data-processing pipelines as you write the code.
Introduction to Kotlin Language and its application to Android platformEastBanc Tachnologies
Author: Oleg Godovykh, eastbanctech.com
Kotlin is a new programming language built by Jetbrains and is a new member of JVM family. As opposed to typical reason to introduce some new language, Kotlin main goal isn't to create new paradigm or fill a new niche, but to make routine tasks much easier and safer. Kotlin gains popularity across Android developer community, and in this presentation it is shown how Kotlin usage can dramatically simplify typical mobile app development.
Have questions about how to script or integrate a desired feature? Titanium Studio offers a wealth of opportunities for modifying and extending behavior through both Eclipse plugins and Rubles, Studio's own scripting interface.
Ingo Muschenetz, Director of Tools Engineering, will lead a deep dive into the scripting interface of Titanium Studio to show how you can customize and extend Studio to better fit your preferences and workflow. We'll cover themes, scopes, commands, snippets, project templates and content assist showing possible approaches and solutions to easily modifying existing functionality, providing your own, and sharing with others.
This session is for developers of all skill levels, with discussion and explanation of several use cases.
The openCypher Project - An Open Graph Query LanguageNeo4j
We want to present the openCypher project, whose purpose is to make Cypher available to everyone – every data store, every tooling provider, every application developer. openCypher is a continual work in progress. Over the next few months, we will move more and more of the language artifacts over to GitHub to make it available for everyone.
openCypher is an open source project that delivers four key artifacts released under a permissive license: (i) the Cypher reference documentation, (ii) a Technology compatibility kit (TCK), (iii) Reference implementation (a fully functional implementation of key parts of the stack needed to support Cypher inside a data platform or tool) and (iv) the Cypher language specification.
We are also seeking to make the process of specifying and evolving the Cypher query language as open as possible, and are actively seeking comments and suggestions on how to improve the Cypher query language.
The purpose of this talk is to provide more details regarding the above-mentioned aspects.
We want to present the openCypher project, whose purpose is to make Cypher available to everyone – every data store, every tooling provider, every application developer. openCypher is a continual work in progress. Over the next few months, we will move more and more of the language artifacts over to GitHub to make it available for everyone.
openCypher is an open source project that delivers four key artifacts released under a permissive license: (i) the Cypher reference documentation, (ii) a Technology compatibility kit (TCK), (iii) Reference implementation (a fully functional implementation of key parts of the stack needed to support Cypher inside a data platform or tool) and (iv) the Cypher language specification.
We are also seeking to make the process of specifying and evolving the Cypher query language as open as possible, and are actively seeking comments and suggestions on how to improve the Cypher query language.
The purpose of this talk is to provide more details regarding the above-mentioned aspects.
Strong typing : adoption, adaptation and organisationDamien Seguy
There are tactical reasons to adopt strong typehint: easy validation, less code, fashionable. Besides, the first typehints blend in effortlessly with the current application: it is as if typehint was already there. Later, it appears that scalar types paved the way to more substantial code refactoring. Classes emerge from the initial scalar types, code congregate around important values, types gets more complex. Finally, systemic typehint arrives. Type hints become systemic when they help tame the class dependency hell, and help us plan for the new code. During the session, we’ll cover the various stages of using typehints, with their advantages, and when not to overuse them.
Writing concurrent program is hard; maintaining concurrent program even is a nightmare. Actually, a pattern which helps us to write good concurrent code is available, that is, using “channels” to communicate.
This talk will share the channel concept with common libraries, like threading and multiprocessing, to make concurrent code elegant.
It's the talk at PyCon TW 2017 [1] and PyCon APAC/MY 2017 [2].
[1]: https://tw.pycon.org/2017
[2]: https://pycon.my/pycon-apac-2017-program-schedule/
C has become pretty old school, but the way C developers now and throughout its history have used C, extended C is the foundation of a amazing dynamic languages. This talk describes some dynamic C data structures and also gives an overview of developing a language on top of these tools.
Enhancing Research Orchestration Capabilities at ORNL.pdfGlobus
Cross-facility research orchestration comes with ever-changing constraints regarding the availability and suitability of various compute and data resources. In short, a flexible data and processing fabric is needed to enable the dynamic redirection of data and compute tasks throughout the lifecycle of an experiment. In this talk, we illustrate how we easily leveraged Globus services to instrument the ACE research testbed at the Oak Ridge Leadership Computing Facility with flexible data and task orchestration capabilities.
Atelier - Innover avec l’IA Générative et les graphes de connaissancesNeo4j
Atelier - Innover avec l’IA Générative et les graphes de connaissances
Allez au-delà du battage médiatique autour de l’IA et découvrez des techniques pratiques pour utiliser l’IA de manière responsable à travers les données de votre organisation. Explorez comment utiliser les graphes de connaissances pour augmenter la précision, la transparence et la capacité d’explication dans les systèmes d’IA générative. Vous partirez avec une expérience pratique combinant les relations entre les données et les LLM pour apporter du contexte spécifique à votre domaine et améliorer votre raisonnement.
Amenez votre ordinateur portable et nous vous guiderons sur la mise en place de votre propre pile d’IA générative, en vous fournissant des exemples pratiques et codés pour démarrer en quelques minutes.
Globus Connect Server Deep Dive - GlobusWorld 2024Globus
We explore the Globus Connect Server (GCS) architecture and experiment with advanced configuration options and use cases. This content is targeted at system administrators who are familiar with GCS and currently operate—or are planning to operate—broader deployments at their institution.
We describe the deployment and use of Globus Compute for remote computation. This content is aimed at researchers who wish to compute on remote resources using a unified programming interface, as well as system administrators who will deploy and operate Globus Compute services on their research computing infrastructure.
Gamify Your Mind; The Secret Sauce to Delivering Success, Continuously Improv...Shahin Sheidaei
Games are powerful teaching tools, fostering hands-on engagement and fun. But they require careful consideration to succeed. Join me to explore factors in running and selecting games, ensuring they serve as effective teaching tools. Learn to maintain focus on learning objectives while playing, and how to measure the ROI of gaming in education. Discover strategies for pitching gaming to leadership. This session offers insights, tips, and examples for coaches, team leads, and enterprise leaders seeking to teach from simple to complex concepts.
How to Position Your Globus Data Portal for Success Ten Good PracticesGlobus
Science gateways allow science and engineering communities to access shared data, software, computing services, and instruments. Science gateways have gained a lot of traction in the last twenty years, as evidenced by projects such as the Science Gateways Community Institute (SGCI) and the Center of Excellence on Science Gateways (SGX3) in the US, The Australian Research Data Commons (ARDC) and its platforms in Australia, and the projects around Virtual Research Environments in Europe. A few mature frameworks have evolved with their different strengths and foci and have been taken up by a larger community such as the Globus Data Portal, Hubzero, Tapis, and Galaxy. However, even when gateways are built on successful frameworks, they continue to face the challenges of ongoing maintenance costs and how to meet the ever-expanding needs of the community they serve with enhanced features. It is not uncommon that gateways with compelling use cases are nonetheless unable to get past the prototype phase and become a full production service, or if they do, they don't survive more than a couple of years. While there is no guaranteed pathway to success, it seems likely that for any gateway there is a need for a strong community and/or solid funding streams to create and sustain its success. With over twenty years of examples to draw from, this presentation goes into detail for ten factors common to successful and enduring gateways that effectively serve as best practices for any new or developing gateway.
AI Pilot Review: The World’s First Virtual Assistant Marketing SuiteGoogle
AI Pilot Review: The World’s First Virtual Assistant Marketing Suite
👉👉 Click Here To Get More Info 👇👇
https://sumonreview.com/ai-pilot-review/
AI Pilot Review: Key Features
✅Deploy AI expert bots in Any Niche With Just A Click
✅With one keyword, generate complete funnels, websites, landing pages, and more.
✅More than 85 AI features are included in the AI pilot.
✅No setup or configuration; use your voice (like Siri) to do whatever you want.
✅You Can Use AI Pilot To Create your version of AI Pilot And Charge People For It…
✅ZERO Manual Work With AI Pilot. Never write, Design, Or Code Again.
✅ZERO Limits On Features Or Usages
✅Use Our AI-powered Traffic To Get Hundreds Of Customers
✅No Complicated Setup: Get Up And Running In 2 Minutes
✅99.99% Up-Time Guaranteed
✅30 Days Money-Back Guarantee
✅ZERO Upfront Cost
See My Other Reviews Article:
(1) TubeTrivia AI Review: https://sumonreview.com/tubetrivia-ai-review
(2) SocioWave Review: https://sumonreview.com/sociowave-review
(3) AI Partner & Profit Review: https://sumonreview.com/ai-partner-profit-review
(4) AI Ebook Suite Review: https://sumonreview.com/ai-ebook-suite-review
Software Engineering, Software Consulting, Tech Lead, Spring Boot, Spring Cloud, Spring Core, Spring JDBC, Spring Transaction, Spring MVC, OpenShift Cloud Platform, Kafka, REST, SOAP, LLD & HLD.
GraphSummit Paris - The art of the possible with Graph TechnologyNeo4j
Sudhir Hasbe, Chief Product Officer, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
A Study of Variable-Role-based Feature Enrichment in Neural Models of CodeAftab Hussain
Understanding variable roles in code has been found to be helpful by students
in learning programming -- could variable roles help deep neural models in
performing coding tasks? We do an exploratory study.
- These are slides of the talk given at InteNSE'23: The 1st International Workshop on Interpretability and Robustness in Neural Software Engineering, co-located with the 45th International Conference on Software Engineering, ICSE 2023, Melbourne Australia
Introducing Crescat - Event Management Software for Venues, Festivals and Eve...Crescat
Crescat is industry-trusted event management software, built by event professionals for event professionals. Founded in 2017, we have three key products tailored for the live event industry.
Crescat Event for concert promoters and event agencies. Crescat Venue for music venues, conference centers, wedding venues, concert halls and more. And Crescat Festival for festivals, conferences and complex events.
With a wide range of popular features such as event scheduling, shift management, volunteer and crew coordination, artist booking and much more, Crescat is designed for customisation and ease-of-use.
Over 125,000 events have been planned in Crescat and with hundreds of customers of all shapes and sizes, from boutique event agencies through to international concert promoters, Crescat is rigged for success. What's more, we highly value feedback from our users and we are constantly improving our software with updates, new features and improvements.
If you plan events, run a venue or produce festivals and you're looking for ways to make your life easier, then we have a solution for you. Try our software for free or schedule a no-obligation demo with one of our product specialists today at crescat.io
Enterprise Resource Planning System includes various modules that reduce any business's workload. Additionally, it organizes the workflows, which drives towards enhancing productivity. Here are a detailed explanation of the ERP modules. Going through the points will help you understand how the software is changing the work dynamics.
To know more details here: https://blogs.nyggs.com/nyggs/enterprise-resource-planning-erp-system-modules/
Globus Compute wth IRI Workflows - GlobusWorld 2024Globus
As part of the DOE Integrated Research Infrastructure (IRI) program, NERSC at Lawrence Berkeley National Lab and ALCF at Argonne National Lab are working closely with General Atomics on accelerating the computing requirements of the DIII-D experiment. As part of the work the team is investigating ways to speedup the time to solution for many different parts of the DIII-D workflow including how they run jobs on HPC systems. One of these routes is looking at Globus Compute as a way to replace the current method for managing tasks and we describe a brief proof of concept showing how Globus Compute could help to schedule jobs and be a tool to connect compute at different facilities.
In 2015, I used to write extensions for Joomla, WordPress, phpBB3, etc and I ...Juraj Vysvader
In 2015, I used to write extensions for Joomla, WordPress, phpBB3, etc and I didn't get rich from it but it did have 63K downloads (powered possible tens of thousands of websites).
Understanding Globus Data Transfers with NetSageGlobus
NetSage is an open privacy-aware network measurement, analysis, and visualization service designed to help end-users visualize and reason about large data transfers. NetSage traditionally has used a combination of passive measurements, including SNMP and flow data, as well as active measurements, mainly perfSONAR, to provide longitudinal network performance data visualization. It has been deployed by dozens of networks world wide, and is supported domestically by the Engagement and Performance Operations Center (EPOC), NSF #2328479. We have recently expanded the NetSage data sources to include logs for Globus data transfers, following the same privacy-preserving approach as for Flow data. Using the logs for the Texas Advanced Computing Center (TACC) as an example, this talk will walk through several different example use cases that NetSage can answer, including: Who is using Globus to share data with my institution, and what kind of performance are they able to achieve? How many transfers has Globus supported for us? Which sites are we sharing the most data with, and how is that changing over time? How is my site using Globus to move data internally, and what kind of performance do we see for those transfers? What percentage of data transfers at my institution used Globus, and how did the overall data transfer performance compare to the Globus users?
Software Engineering, Software Consulting, Tech Lead.
Spring Boot, Spring Cloud, Spring Core, Spring JDBC, Spring Security,
Spring Transaction, Spring MVC,
Log4j, REST/SOAP WEB-SERVICES.
Providing Globus Services to Users of JASMIN for Environmental Data AnalysisGlobus
JASMIN is the UK’s high-performance data analysis platform for environmental science, operated by STFC on behalf of the UK Natural Environment Research Council (NERC). In addition to its role in hosting the CEDA Archive (NERC’s long-term repository for climate, atmospheric science & Earth observation data in the UK), JASMIN provides a collaborative platform to a community of around 2,000 scientists in the UK and beyond, providing nearly 400 environmental science projects with working space, compute resources and tools to facilitate their work. High-performance data transfer into and out of JASMIN has always been a key feature, with many scientists bringing model outputs from supercomputers elsewhere in the UK, to analyse against observational or other model data in the CEDA Archive. A growing number of JASMIN users are now realising the benefits of using the Globus service to provide reliable and efficient data movement and other tasks in this and other contexts. Further use cases involve long-distance (intercontinental) transfers to and from JASMIN, and collecting results from a mobile atmospheric radar system, pushing data to JASMIN via a lightweight Globus deployment. We provide details of how Globus fits into our current infrastructure, our experience of the recent migration to GCSv5.4, and of our interest in developing use of the wider ecosystem of Globus services for the benefit of our user community.
6. Looking back: why scala?
• Increase productivity
• Be more attractive employer
• Team decision
7. Looking back: good vs bad
Good
• Functional programming
• Terse syntax
• JVM ecosystem
• Gentle learning curve
• DSL friendly syntax
• Motivated team
Bad
• Tool support
• Compilation times
• Language complexity #moreRope
9. Fast-forward (Aug 2013)
• 2.5 years into project
• 1.5 years of weekly live releases
• 100k LOC
• >10k commits
• >90 committers
10. Fast-forward (Aug 2013)
• 2.5 years into project
• 1.5 years of weekly live releases
• 100k LOC
• >10k commits
• >90 committers
not all related to Scala - to be fair
• Poor feedback loops
• Lots of accidental complexity
15. What did we do
• Reduced build time
• Improved feedback loops
• Reduced accidental complexity
16. Build time
• Reduced size of codebase (broke off vertical slices, pulled out APIs, pulled out libraries,
removed unused features, removed low-value tests, etc.)
• Reduced usage of certain language features (esp. traits and implicits)
20. The problem with traits
• Will re-compile on every class the trait is mixed in
• Slows down dev-build cycle
• Will result in byte code bloat
• Will compile *a lot* slower
!
For faster compile times:
• Use pure traits
• Use old-school composition for code re-use
• Use pure functions via imports (e.g. import Foo._)
• If unavoidable, use inheritance for code re-use
27. Complexity
• There’s still a lot of code in our codebase that is hard to read
• It seems to be very easy to shoot yourself in the foot with Scala
• Scala *is* complex (and that’s why scalac will never be as fast as javac)
28. Complexity
• There’s still a lot of code in our codebase that is hard to read
• It seems to be very easy to shoot yourself in the foot with Scala
• Scala *is* complex (and that’s why scalac will never be as fast as javac)
Invariant/covariant/contravariant types (T, +T and -T)
Refined types (new Foo {...})
Structural types (x: {def y: Int})
Path dependant types (a.B)
Specialized types (@specialized)
Self types (this =>)
Projection types (A#B)
Existential types (M[_])
Type bounds (<:, >:)
Type constraints (=:=, <:< and <%<)
Type members (type T)
Type aliases (type T = Int)
Type classes ( (implicit ...) )
View bounds (<%)
Higher kinded types (* => *)
F-Bounded type polymorphism (M[T <: M[T]])
http://nurkiewicz.github.io/talks/2014/scalar/#/16
29. Not opinionated
For example: http://twitter.github.io/effectivescala/
• Many ways to do the same thing
• Coding conventions help, but only so much
30. Not opinionated
def foo() = "foo"
def bar = "bar"
!
foo
foo()
bar
bar() // won't compile
For example: http://twitter.github.io/effectivescala/
• Many ways to do the same thing
• Coding conventions help, but only so much
31. Not opinionated
def foo() = "foo"
def bar = "bar"
!
foo
foo()
bar
bar() // won't compile
For example: http://twitter.github.io/effectivescala/
• Many ways to do the same thing
• Coding conventions help, but only so much
def baz(x: String) = x
“x”.charAt(0)
“x” charAt(0) // won't compile
“x”.charAt 0 // won't compile
“x” charAt 0
baz("x")
baz “x" // won't compile
32. Not opinionated
def foo() = "foo"
def bar = "bar"
!
foo
foo()
bar
bar() // won't compile
list.foreach { x => println(x) }
list.foreach ( x => println(x) )
list.foreach { println(_) }
list.foreach ( println(_) )
list foreach { x => println(x) }
list foreach ( x => println(x) )
list foreach { println(_) }
list foreach ( println(_) )
For example: http://twitter.github.io/effectivescala/
• Many ways to do the same thing
• Coding conventions help, but only so much
def baz(x: String) = x
“x”.charAt(0)
“x” charAt(0) // won't compile
“x”.charAt 0 // won't compile
“x” charAt 0
baz("x")
baz “x" // won't compile
33. Not opinionated
def foo() = "foo"
def bar = "bar"
!
foo
foo()
bar
bar() // won't compile
list.foreach { x => println(x) }
list.foreach ( x => println(x) )
list.foreach { println(_) }
list.foreach ( println(_) )
list foreach { x => println(x) }
list foreach ( x => println(x) )
list foreach { println(_) }
list foreach ( println(_) )
if (foo) "x" else "y"
foo match {
case true => "x"
case _ => "y"
}
For example: http://twitter.github.io/effectivescala/
• Many ways to do the same thing
• Coding conventions help, but only so much
def baz(x: String) = x
“x”.charAt(0)
“x” charAt(0) // won't compile
“x”.charAt 0 // won't compile
“x” charAt 0
baz("x")
baz “x" // won't compile
39. Implicits
• Can make it very hard to read code
• Tool support is very bad
• Impacts compilation time
• Surprising behaviour (esp. when used with overloaded methods or optional params)
40. Tooling
def handle(response: HttpResponse, request: HttpRequest)
• Tool support is still very basic
• Makes it hard to continuously refactor (which means people are less likely to do it)
41. Tooling
def handle(response: HttpResponse, request: HttpRequest)
• Tool support is still very basic
• Makes it hard to continuously refactor (which means people are less likely to do it)
no luck with “change signature”
refactoring support
44. Trait entanglements
• Makes it difficult to reason about behaviour
trait A {
def foo = "a"
}
trait B extends A {
override def foo = "b"
}
45. Trait entanglements
• Makes it difficult to reason about behaviour
trait A {
def foo = "a"
}
trait B extends A {
override def foo = "b"
}
class C extends A with B
new C().foo
46. Trait entanglements
• Makes it difficult to reason about behaviour
trait A {
def foo = "a"
}
trait B extends A {
override def foo = "b"
}
class C extends A with B
new C().foo
"b"
47. Trait entanglements
• Makes it difficult to reason about behaviour
trait A {
def foo = "a"
}
trait B extends A {
override def foo = "b"
}
class C extends A with B
new C().foo
"b"
class D extends B with A
new D().foo
48. Trait entanglements
• Makes it difficult to reason about behaviour
trait A {
def foo = "a"
}
trait B extends A {
override def foo = "b"
}
class C extends A with B
new C().foo
"b"
class D extends B with A
new D().foo
"b"
55. Today
• We’ve delivered successfully using Scala
• Don’t think we’re more productive (pure gut feeling, though)
• We try to stick to the good parts (conventions, functional programming, pattern matching, etc.)
• Complexity, slow compilation and lack of tool support are real problems
56. The future
• No urgency to move away from Scala or re-write existing systems
• Java 8 is an alternative
• Smaller teams and apps will probably lead to more polyglotism (and less Scala)