Scalac was born in 2014 to resolve challenges associated with handling the big data

Scalac

scalac

This is more examples than talk. Add ScalaCheck to your file build.sbt First Problem, FizzBuzz Let’s look at some tests for FizzBuzz problem. Each test is trying to prove certain property of FizzBuzz, for instance, property “only div by 3” is trying to prove that Fizz is only returned when the passed value is divisible by 3 and not by 5. Taking a look at the value generator ( ) will allow us to realized we are filtering out those that are divisible by 5. divBy3 Following the same like of thinking we can prove other properties out such as only those that are divisible by 5 and not by 3 should be translated to “Buzz”, or if the value is not divisible by 3 and by 5 it should be translated using the id function and toString, so they become themselves in string format. The magic here is that each test will run at least 100 times with a randomized value space (that is not stable) based on our generator properties. This is, in my opinion, stronger that testing for using limited values of the problem domain, such as 5, 10, 15, 2, 24, 2. On the other hand, this testing techniques should not replace TDD but rather extend it for more complete test suite. Our implementation of FizzBuzz looks like this. Second Problem, Stack Now, let’s see how we can use the same technique to test a custom, yet functional stack implementation. Size Let’s start by the tests since they are our area of focus in the post. First, we define a value generator, specifically for positives int values. Then we define our first test that a number of values (in order) to the stack and verify that the size of the stack corresponds to the number of values that were pushed. push Remember, this same test will run 100 times with a different number of values to be pushed. The first time it runs might be pushing 2 values and verifying that the size is 2 and then it might run again and pushes 97 values and again verifies that the size of the stack is 97. Pick Our second test verifies that from the stack does not modify it. pick Using the same principle, the test runs a lot of times, pushing a different number of items into the stack every time and then calling ( ) and then verifying that the size is equals to the number of values that were pushed, which means does not modify the stack. .head pick .head toList Now, we can test getting a list representation of the stack (does not modify the stack). Once more, using the same principle, each time the test runs, it checks that returns the same values that we pushed in reversed order. .toList Push & Pull Our “push pull” test verifies that whatever we pushed into the stack can be pulled out in the right order. Again, this test will run 100 times with different stack sizes. Stack Our Stack is an inmutable data structure. Operations on the stack does not modify it but rather create new stacks. Conclusions Property-based testing is a powerful tool to have in your side. I have found it very useful when writing complex data structure like the ones we have been adding to . However, it should not replace other techniques such as TDD (Test Driven Development) but rather complement them. Dogs

Exploring Property-Based Testing with ScalaCheck (simple examples)

Developing Streaming Data Lakes with Hudi and MinIO

Desarrollo de streaming de lagos de datos con Hudi y MinIO

Développer des lacs de données de streaming avec Hudi et MinIO

हुडी और मिनिओ के साथ स्ट्रीमिंग डेटा लेक विकसित करना

Hudi と MinIO を使用したストリーミング データ レイクの開発

Desenvolvendo Streaming Data Lakes com Hudi e MinIO

Phát triển các hồ dữ liệu phát trực tuyến với Hudi và MinIO

使用 Hudi 和 MinIO 开发流数据湖

How is it even possible? In this article, I describe Scala performance tips based on my experience of optimizing . I found that some typical Scala code fragments have surprisingly much faster alternatives. The tips below can help you to avoid accidental performance issues and write faster Scala code for no additional effort. There is also source . Ergo's smart contracts interpreter code with all the benchmarks Scala provides powerful constructs and idioms to build abstractions for correctness and clarity but may have runtime performance penalties. When solving a task, there may be several alternative solutions, each with its own performance characteristics. Even similar-looking code can have radically different performance. Teams often specify things like formatting and documentation to make sure the code stays consistent and good quality. Similarly, tips on making the code run faster can also be useful. Performance improvement can come from almost no special effort. As such, it is a matter of coding style and habits rather than a matter of extensive code optimization, which shouldn't be . premature The code speedups described below are only examples and not necessarily exact numbers, as there may be various factors that can impact the timings. Nevertheless, after systematically applying the outlined recommendations, I have observed strictly positive effects on performance. Performance tips Tip 1: Avoid Seq() Let's start with the simplest. It's not uncommon to see the use of wherever an empty
collection is required. However, this method involves the following: Seq() an empty array is initiated the array is wrapped into an instance of ArraySeq the following methods called: -> -> -> SeqFactory$Delegate.apply IterableFactory.apply List.from Nil.prependAll Nil object returned in the end What to use instead Simple is 20-28% faster (see Benchmark: Seq) depending on whether the JIT is able to inline the invocation all the way down to or not. So, why not help it and use directly? Nil Seq() Nil Nil Tip 2: Avoid Map() Next one is . It is often used wherever an empty Map is required. However, as is the case with , this method involves allocations and many method calls. Map() Seq() What to use instead Calling is 25-85% faster, depending on the context (see  Benchmark: Map) Map.empty Tip 3: Avoid comprehensions for Looping pattern is used quite often due to its convenience.
It looks very similar to the loop in Java, but it is not. for (x <- xs) { ... } for In Scala, it is desugared by the compiler to which, besides execution of the block of code involves the following list of overheads: xs.foreach { x => ... } method call foreach allocation of lambda object boxing (memory allocation) of the value for every item (if xs values are not yet boxed) x xs hidden overhead of concrete implementation of method foreach Such comprehensions are particularly (see ) for Range loops, where is an . for sub-optimal Benchmark: for over Range x Int What to use instead There is a macro from library. cfor spire I recommend the following code as a replacement when provides an O(1) indexing access,
for example if is an or an array wrapped into . xs xs Array Seq import spire.syntax.cfor._
cfor(0)(_ < xs.length, _ + 1) { i => 
  val x = xs(i)
      ...
} The above collection can also be a in which case can be replaced with xs Range for (x <- 0 until n) { ... } cforRange(0 until n) { x => ... } These macros are compiled to efficient Java loop without overhead points 1) - 4). Depending on it is 10-170x faster (see Benchmark: for over Range). And since already implies a side effect operation, doesn't make the code any less readable. cfor xs.length foreach cfor Note, however, that is not a silver bullet. It is NOT a replacement for in the case of non-indexed collections, when indexed access is NOT a fast O(1) operation. In many cases using instead of is a no-brainer and often increases the performance of any code which loops over an indexed collection (see for example Benchmark: dot-product and Benchmark: check brackets). cfor foreach cfor foreach Tip 4: Avoid creating sequences with Seq(...) It is tempting to use method where a Seq of items is required like because it is easy and concise. You can pass it as a method argument or as a method result. Seq.apply Seq(1, 2, 3) However, the following happens under the hood: new Array with the items is created, and each item is boxed into its own Integer object 1, 2, 3 WrappedArray#ofInt wrapper is created and passed as vararg argument of Seq.apply the above-mentioned methods down to are called Nil.prependAll new ListBuffer is created and all items are copied from array to the buffer Benchmarks show that JIT is not able to fully optimize this code. What to use instead Simple drop-in replacement performs better. This code is 4-10x faster
than using . (see ). The speedup is even more significant when the number of items in the sequence grows (see ). Array(1, 2, 3) Seq(1, 2, 3) Benchmark: Seq vs Array Benchmark: Seq vs Array (from Range) What happens here is that: native unboxed Java array is created and then wrapped via implicit conversion into a which is inherited from the trait and can be used directly. WrappedArray#ofInt Seq Why is this faster? It avoids unnecessary allocations (only two new objects are allocated in the Array case).
Note that to create not only each Int is boxed into java.lang.Integer (or other primitive type),
but also instances are created for each item of the list. Seq scala.collection.immutable.:: Creating Array avoids boxing (which is proportional to the size of Seq). Accessing of array items is cache friendly both when the array is created and
when it is later used. Fewer allocations mean less garbage to collect later. This is especially important when the application is multithreaded because, in this case the garbage collector will compete with application threads for CPU resources, thus further slowing down the application. Notice that using arrays like this doesn't make the code any less readable. Moreover, the arrays created in this way are only accessible via interface, which is immutable. Thus, better performance is achieved without sacrificing other desirable code qualities like readability, safety, and conciseness. Seq Caveat: the array is not efficient if it is accessed using list operations and . See, for example, . In this case, replacing with may lead to performance degradation. However, using lists in a performance-critical code may not be a good idea as well. head tail Seq vs Array (list ops) benchmark Seq Array Tip 5: Avoid extractors with Option An extractor is an object with an method taking an arbitrary argument and returning an of some (maybe different) type. Here is a simple example: unapply Option object IsEven:
  def unapply(n: Int): Option[Int] =
    if (n % 2 == 0) Some(n) else None With extractors, pattern matching can be concise and expressive. However, returning an might have a negative impact on runtime performance because on every matching call an instance of needs to be created for each successful extraction. unapply Option Some What to use instead Since version 2.11, Scala introduces that no longer requires to return an . Combined with these two features allow implementing extractors, which are 10-70% faster than the original based extractors (see ). name based extractors unapply Option value classes allocation-free Option Benchmark: Option vs Opt object IsEvenOpt:
  def unapply(n: Int): Opt[Int] =
    if (n % 2 == 0) Opt(n) else Opt.empty A suitable implementation of class can be found in the library. Opt spire Benchmarks Summary The following tables summarize the results of the benchmarks run on the code snippets above and the following configuration: osArch: aarch64; osName: Mac OS X OpenJDK 64-Bit Server VM; vendor: Eclipse Adoptium; version: 17.0.5+8 You can reproduce the results on your computer by running the . Benchmarks class Clone the repository and run . sbt "Test/runMain benchmarks.Benchmark" Benchmark: Seq Size Seq(), ms Nil, ms Speedup 10 0.0001250 0.0001250 1.00 100 0.0002080 0.0002080 1.00 1000 0.0007500 0.0006250 1.20 10000 0.0065830 0.0051250 1.28 100000 0.0625830 0.0502920 1.24 Benchmark: Map Size Map(), ms Map.empty, ms Speedup 10 0.0001250 0.0001250 1.00 100 0.0002080 0.0001660 1.25 1000 0.0010410 0.0006250 1.67 10000 0.0091670 0.0050830 1.80 100000 0.0902500 0.0487080 1.85 Benchmark: foreach vs cfor Size foreach, ms cfor, ms Speedup 10 0.0006660 0.0000830 8.02 100 0.0007500 0.0000830 9.04 1000 0.0025830 0.0001250 20.66 10000 0.0238330 0.0003330 71.57 100000 0.2244170 0.0042910 52.30 Benchmark: for over Range Size foreach, ms cforRange, ms Speedup 10 0.0004160 0.0000830 5.01 100 0.0009160 0.0000830 11.04 1000 0.0061250 0.0001250 49.00 10000 0.0569170 0.0003330 170.92 100000 0.5648750 0.0042500 132.91 Benchmark: Seq vs Array (from elems) Size Seq, ms Array, ms Speedup 10 0.0007910 0.0002080 3.80 100 0.0066250 0.0008340 7.94 1000 0.0661660 0.0160000 4.14 10000 0.6733330 0.0679170 9.91 100000 6.8687920 0.6750420 10.18 Benchmark: Seq vs Array (from Range) Size Seq, ms Array, ms Speedup 10 0.0120420 0.0066250 1.82 100 0.0836670 0.0160830 5.20 1000 0.8315420 0.0533340 15.59 10000 8.1187080 0.5097500 15.93 100000 81.0221660 4.5335830 17.87 Benchmark: Seq vs Array (list ops) Size Seq, ms Array, ms Speedup 1 0.0003330 0.0003750 0.89 10 0.0005840 0.0007500 0.78 100 0.0030410 0.0042500 0.72 1000 0.0295000 0.1258330 0.23 10000 0.2695000 15.5551250 0.02 Benchmark: Option vs Opt Size Option, ms Opt, ms Speedup 100 0.0004160 0.0003750 1.11 1000 0.0014160 0.0009160 1.55 10000 0.0117910 0.0069580 1.69 100000 0.1155420 0.0666670 1.73 1000000 1.1547090 0.6657910 1.73 Benchmark: dot-product Size slow, ms fast, ms Speedup 10 0.0050000 0.0011250 4.44 100 0.0059160 0.0016660 3.55 1000 0.0242090 0.0073750 3.28 10000 0.1297920 0.1235000 1.05 100000 1.4926660 0.8446250 1.77 Benchmark: check brackets Size slow, ms fast, ms Speedup 1 0.0007080 0.0002500 2.83 10 0.0017080 0.0005000 3.42 100 0.0077500 0.0027090 2.86 1000 0.0753340 0.0260000 2.90 10000 0.7195830 0.2587080 2.78 Concluding remarks Program performance upkeep & optimization is the result of constant vigilance and work, rather than just a one-time job. There is no solution as there are
many trade-offs along the way. one size fits all The tips presented in this article are so simple that they can be applied and regardless of whether you have already identified the bottleneck or not. Back to my experience, once I systematically applied these tips all over the code base, those parts of code disappeared from the profiler's hot spots bringing up on the surface other bottlenecks by default and simplifies profiling. For further reading, I collected a list of useful references on the topic of Scala optimization. Happy optimizing! References Scala Style Guide Scala High Performance Programming (somewhat outdated) Optimizing Higher-Order Functions in Scala Where to look first when optimizing Scala code? Scala for comprehension performance Performance characteristics of Scala collections Java Performance: The Definitive Guide: Getting the Most Out of Your Code Scala library benchmarks JITWatch Parallel Collections: Measuring Performance JVM JIT optimization techniques Name Based Extractors in Scala 2.11

How to Optimize Scala Code Performance With Almost No Effort

. This article is based on a story of one of our developers, ex Java now Scala developer, who decided to follow the Scala path because he found writing in Scala extremely developing and interesting Scala programming is definitely one of the main topics that come to mind when it comes to , the company I work at (the name itself is actually Scala + C = Scala compiler). As you can probably tell from the name of our brand, before we developed teams like Data Engineers, DevOps, UX/UI and Frontend, our company was powered by Scala experts - even now, we are one of the biggest Scala company in the world, and a Gold Lightbend Partner. Scalac Some time ago I started wondering; what is it about Scala that developers prefer over other languages? Why do we need Scala?  This post was originally meant to be focusing on Scala vs Kotlin comparison - so we interviewed our senior engineer (who was previously a Java engineer) just to find out, that there is a way better story to tell - about how Scala makes Developers enjoy their work again. Let me take you on a journey to discover the ultimate truth! On the first day, there was Java Java was developed in the early 1990s and it changed the whole IT world. In the early 90s, the idea of extending the power of network computing to the activities of everyday life was something totally abstract. Today, with technology being such a great part of our daily lives, we take it for granted. As a matter of fact, Java is still, after all these years, an engine that runs many applications - from games to business solutions. The slow evolution of the Java programming language has led to quite a few inventions in the JVM programming languages. As a result, there are over 50 JVM languages! They were all created to fill in the gaps in existing versions of Java by developers who didn’t settle on “good enough”. The real question is: is Java enough? In theory, Java can be used for everything -  a mobile app, a server, an e-commerce platform. In practice - if you want a mobile app you're better off with Kotlin, and if anything regarding your solution is more complex and requires a big amount of data Scala is a way to go. On the second day, there was Kotlin Sorry to have to put it this way but Kotlin is just Java in a nicer package  - still an object-oriented language but fresher and funkier. It’s so similar that it doesn’t require a different mindset. Java developers are able to quickly switch to Kotlin and program smoothly in it. You can also call Java code from Kotlin and vice versa without any hassle. Moreover, apart from that, it has several other advantages, such as the way the collection library is built, support for nulls, and coroutines. Kotlin supports functional constructions, but it is still closer to Java deprived of its old-fashioned legacy than to Scala. It gives Java programmers freshness and constructions that are not available in Java, as well as brevity in expressing thoughts through code. Kotlin’s domain in contrast to Scala is mobile. It can be used for both server and client (mobile) development - Frontend and Backend. Android supports Kotlin out of the box. You can also use Scala for that purpose but it is not as hassle-free as Kotlin. Scala vs Kotlin popularity in USA Source: Google Trends I chose Scala as a junior because in a way it can be easy to start with. (it can be introduced in a procedural paradigm at first), but at the same time, it has all the necessary concepts to learn it. without having to switch to other functional languages. Scala also shares C-like familiarities so too. You don’t have to jump straight into object-oriented programming You can move over to functional programming it’s easy to learn C-style languages Patryk Kirszenstein, Junior Scala Developer at Scalac and on the third day… there was Scala As mentioned before, some Java developers knew that they couldn’t quite settle for what they had. They wanted more. They were looking for an alternative, where nicer syntax could be used. Scala as a programming language with functional facilities requires a different mindset and much more knowledge than Java or Kotlin because of the fact that, among other things, code is written differently. In Scala, you can write functional and object-oriented code. It has a very rich syntax that enables you to write code in many ways. This is also why people who are not involved with Scala may have the impression that it’s over-complicated. This is because, in the case of Java and Kotlin, programmers know what to expect. With languages like Scala - you go big or you go home. Systems written in strongly typed languages like Scala are easier to maintain in the long term. Also, a big business-related advantage is that it’s a JVM compiled language so you can use all the existing Java libraries. Did you know that Scala, although not so popular as Java, it's also used by world-wide enterprises which seems to see its advantages like Zalando, LinkedIn, Twitter, Foursquare, Netflix, Tumblr, Walmart, Paypal, Intel and Samsung?. What are the business reasons to use Scala? If you’re working with complex environments, applications, analytics it’s way more efficient than Java or Kotlin. Scala is used to implement Spark (the leading platform for distributed data processing)  as well as to define the computations themselves, so it’s really data-scientist-friendly. Not to mention that Scala is a great language for domains like Machine Learning and Blockchain which are extremely important in today’s business, and will become even more significant in the future. Scala is pure Challenges may be the key to why Scala has such a big community - especially for a seemingly niche language - with over 95 919 questions asked solely about Scala on StackOverflow (not to mention related topics). Scala is a powerful language with highly-advantageous features and flexible syntax. But, it is quite difficult for developers to get a grip on this JVM programming language. However, with time, it becomes really natural and straightforward. What Scala represents, with its functional approach, is passion-driven work leading to pure self-development. To fall in love with it, you need to first start writing in it, and then dig a little deeper. Scratching the surface may only give you the wrong idea. “While many languages share some of Scala’s features, few share so many of them, making Scala unique in ease of development. Dorian Sarnowski, Senior Scala developer at Scalac At Scalac we use Scala for a variety of reasons, which mostly come down to reducing development time and reducing the number of bugs in code. While many languages share some of Scala’s features, few share so many of them, making Scala unique in ease of development. Scala - simply beautiful. Scala really encourages switching from mutable data structures to immutable, and from regular methods to pure functions (without getting crazy about it like Haskell).  It’s simply beautiful. It provides a good balance between the conciseness of a language, extensibility, and performance. Keeping to JVM’s paradigm promise of “write once, run anywhere”, and combining it with functional coding, Scala lets you build the best of both worlds in your code. It's functional I don’t think there is any programmer who wouldn't find Functional Programming interesting, but sometimes they just let it go because they have other priorities at work. Fortunately, some jobs actually let you do exactly that for a living and that’s quite amazing. Scala is a very appealing choice for developers who are looking to strike a balance between writing pure code and writing solid code quickly – by building upon existing solutions and libraries when available. That  - combined with interoperability with the Java ecosystem and the JVM - makes Scala look very promising. Scala is more influenced by functional programming languages like Haskell than Kotlin. It encourages the use of functional coding along with some additional features such as pattern matching and currying. Not only that,  but functional programming is also more substantial in the Scala environment. “Scala lets you build the best of both worlds in your code. It's love Scala is functional and type-safe, but you encounter the difficulties progressively (you can still write Java-like code), so at no point will you get bored. It’s more likely you will feel like you are always on an intellectual adrenaline rush. You could poetically compare it to the feeling of falling in love for the first time. I think that’s truly one of the reasons Scala is definitely worth the time you will need to learn it. It will change the way you think forever. Previously published at https://scalac.io/why-does-scala-win-against-kotlin-senior-engineers-opinion/

Senior Engineer`s Opinion: Why Does Scala Win Against Kotlin?

One of the questions my readers often ask me is, Why should Java developers learn Scala,” and so on? “Should Java developers learn Scala ? Does Scala have a better future than Java ? Well, there can be many reasons for learning Scala, like you are forced to learn it because it has been used in the new company you have just joined, or your solution architect decided to use it for the new project you are going to work, but that’s a different story. Here, we’ll talk about the that encourages Java developers to learn Scala. reasons Scala has emerged as one the most powerful Java alternatives in recent times. It’s been the of choice, leaving and way behind, and is preferred as the language people want to write the most code in. JVM language Groovy Kotlin Scala has many strong points, the strongest being that it’s a . multi-paradigm language Along with the superiority of functional programming idioms available to take advantage of multi-core CPU architectures, Scala has the right mix of popular paradigm. object-oriented It not only solves many of Java’s issues, e.g. less to no boilerplate, but it also provides several best practices and patterns right in the language, e.g. immutability with the keyword and case classes. val Despite providing the fluency and flexibility of dynamic languages like , it’s still a strongly statically typed language to prevent you from doing bad things, which just happen at runtime in dynamic languages. Python I am sure Scala developers will add many more reasons into this list, but being from a Java background and ardent supporter of Java, I think Scala definitely has something to offer, and the following reasons make a lot of sense for to learn Scala. Java developers Without any further ado, here is my list of 10 reasons why a programmer should learn Scala: 1. Multi-Paradigm Language Scala is a bit different than Java, as it supports two programming paradigms: object-oriented programming ( ) and functional programming ( ). OOP FP To advance your programming skills, it’s good to learn at least one language from different paradigms, e.g. imperative, logical, functional, and OOP, and Scala gives you a chance to explore both functional and OOP together. The book also advises you to learn a new programming language every year. Pragmatic Programmer The Pragmatic book for Programmers Scala allows you to define types associated with both data attributes (with classes behaving like / classes) and behavior attributes (with traits corresponding to Java interfaces). C++ Java Just like in other functional programming languages, In Scala, (which means you can pass them around as values) and Scala also supports anonymous functions and currying (partial application of multi-argument functions). functions are first-class citizens This combination of features makes it possible to write Scala programs that are quite concise and elegant. Being multi-paradigm is one of the strongest selling points of Scala, which Java 8 has also attempted by introducing lambda expressions (see ), but it is still a couple of steps behind. I think, Scala will always be more functional than Java, but that’s topic of another debate. Java SE 8 New Features 2. Interoperability With Java In my opinion, Scala’s choice of being inter-operable with Java is the best thing happen to Scala. runs on the Java Virtual Machine ( ) and can interoperate nicely with Java code. Scala JVM This also means Scala developers can use Java libraries directly from Scala code. Given, many Java developers are turning to Scala, this is the perfect way of leveraging their years of experience in real-world Java programming. It is also possible to call Scala code from Java, and you can easily write part of your program in Scala and the rest in Java. In short, interoperability with gives Scala huge potential to become mainstream, enterprise programming language, as so much of the world’s code is written in Java and so many developers are working in Java around the world. Java 3. Best Practices and Patterns Built-In Language One thing you might not know about Scala is that it was originally developed at the Swiss university EPFL in an attempt to apply recent innovations in programming language research to a language that can gain mainstream traction, much like Java. Several best practices and patterns are built into the language itself, e.g. val declares top-level , which is much better than the overloaded keyword in Java, or const/read-only in C# with the weird rules associated with it. immutability final It also got , which makes it easy to create immutable Classes in Scala. case classes Scala also offers closures, a feature that dynamic languages like and have adopted from the functional programming paradigm. Python Ruby 4. Expressiveness When you compare Scala with Java as I did in my previous post about the , Scala certainly scores big over Java. differences between Scala and Java Scala is inherently very expressive. There’s also tons and tons of really beautiful and useful code written in Scala. This is attracting more and more Java developers to learn Scala, who like to write beautiful and . clean code To give you an idea, here is the written in both Java and Scala, you can see the difference in the expressiveness of language by yourself. word count program Scala has achieved in just one line what Java has taken more than 10 lines to achieve. Scala code is more clear and concise By the way, things can be improved on the Java side by using like and , which is not used in this example, but still, Scala scores big over Java when it comes to concise and clean code. Java 8 features lambdas stream 5. Marketable What programmer doesn’t want to be marketable? One reason for learning a or framework is always a better job and career growth. new technology Learning Scala will certainly make you more marketable. Many companies are using or migrating to Scala these days, including Twitter, LinkedIn, Foursquare, and Quora. Given Scala’s marketing as Scalable language, the days are not far when the big investment banks and financial organizations will start looking Scala for their low-latency solutions. Similar to the advice given in Twitter has already shared best practices to develop programs in Scala as Effective Scala. Effective Java , The founders of Quora spent a couple of months building a in order to use Scala. Scala web framework , the man behind Scala, is now behind the start-up , formally known as Typesafe for supporting commercial Scala development. Martin Odersky Lightbend Everything is going in the right direction for Scala to grow as the prime alternative to Java. 6. Statically Typed In general, a statically typed language like Java prevents programmers from doing bad things, while, with a dynamic language like , you only know about a bad thing when you run the program. Python Scala has the best of both worlds. It feels dynamic, but it’s strongly statically typed. The Scala compiler is really smart and uses type-inference to its fullest extent. Scala provides type inference for variables and functions, much better than the limited type inference in and . Java C# 7. Growing Frameworks One thing you might know about the ecosystem is that Scala is growing. There are lots of good libraries and frameworks coming around. Companies that have started using Scala are also contributing to the recent growth of Scala as a mainstream language. There are some nice Scala web frameworks out there, including Lift and Play. Akka, another Scala-based concurrent framework has already established itself as toolkit and runtime for building highly concurrent, distributed, and fault-tolerant event-driven applications on the JVM. Scala is also been used in along with , which has further fuelled its adoption by many Java developers interested in Big Data. Big Data space Apache Spark Btw, If you are interested in Spark, then you can also take a look at the course on Udemy. Learn Apache Spark from Scratch 8. Growing Community Along with the language and associated frameworks, the Scala community is also growing. Lots of programmers, including , are joining the Scala bandwagon. Java developers More and more IDEs have started to support Scala syntax, and there’s much better support in and . There’s also great build tool support in SBT, Maven, and Ant. Eclipse IntelliJ In recent surveys, Scala has also been touted as the number one alternative to Java. In my opinion, to grow Scala as the real alternative of Java, given also has support, it has to attract more and more Java developers. Java 8 functional programming Getting big organizations like Twitter to adopt Scala certainly helps the community, as they have more resources and influence. 9. Concise Syntax Java has long been criticized for his verbose and boilerplate-heavy syntax. Though it makes Java more readable, much like English, Scala has set a new benchmark in being concise and readable at the same time. The Scala compiler, known as scalac (remember ) does more than you expect. It can generate , , and other things for you. Consider two code snippets of the same class written in Java and Scala to help you make your choice: javac toString() equals() hasCode() public class Book {
private final String name;
private final double price;

public Star(String name, double price) {
this.name = name;
this.price = price;
}

@Override
public int hashCode() {
int hash = 7;
hash = 23 * hash + Objects.hashCode(this.name);
return hash;
}

@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}

if (getClass() != obj.getClass()) {
return false;
}

final Test other = (Test) obj;

if (!Objects.equals(this.name, other.name)) {
   return false;
}

if (Double.doubleToLongBits(this.price) != Double.doubleToLongBits(other.price)) {
  return false;
}
return true;
}

@Override
public String toString() {
 return "Test{" + "name=" + name + ", price=" + price + '}';
}

} You can write the same thing, using Scala’s case class: case class Book(name: String, price: double) By the way, you can also use the Lombok library, one of the , to remove the boilerplate code related to getters, setters, equals, hashCode, and toString. It can automatically generate those for you. essential libraries for Java developers 10. Easier to Learn compared to Haskell, other Functional Programming languages For a Java developer, learning a classical functional programming language like Haskell or OCaml is rather more difficult than Scala. In other words, Scala is relatively easy to learn because of its OOP functionality. While taking their time to learn functional programming, Java developers can still be productive in Scala by leveraging their existing knowledge of . Like , Scala has clean syntax, nice libraries, good online documentation, and lots of people in the industry using it. OOP Java With a growing community of Scala on forums, it’s not difficult to find an answer to any Scala questions, which adds to your learning experience. Conclusion Once you start learning Scala, I am sure you will LOVE IT. It’s not only got a cleaner OO code but also functional capabilities, it feels dynamic (like Python) but it also has a static type system that can prevent you from doing bad things. If you decide to learn Scala in 2018 or 2019, here are some useful resources for further learning. Beginning Scala Programming Scala: Getting Started By Justin Pihony Scala for Java Developers By Toby Weston Scala for the Impatient Functional Programming in Scala All the best with your journey into the beautiful world of Scala and functional programming. If you have any questions or feedback, please drop a note. If you like this article, then please share with your friends and colleagues, and don’t forget to follow javinpaul on Twitter and in Medium! javinpaul P.S. — If you need some FREE resources, you can check out For Beginner — A #FREE Course to start your Scala journey. Scala Programming Mini Boot camp Scala - Hacker Noon

10 Reasons to Learn Scala and Functional Programming

Most of our code currently runs on . Promoting a micro service architecture, we, as many others, soon faced the problem of service discovery. As others face these problems too, you’d probably think that searching for with your search engine of choice will give you loads of nice solutions. Well, we were disappointed. That's why we wrote our own service discovery library which we are proud to open source. This post explains the motives and why we think that our approach is actually the best. AWS aws service discovery Find the Single Point of Truth Service discovery is, at its heart, about asking the right question to a single point of truth. The point which knows about all your services and how to reach them. Lets think about a couple of obvious solutions. The first take is to declare the network itself as the single point of truth. You can use a protocol which usually involves sending multicast or broadcast messages. As there is no support for these on AWS VPC this possibility is ruled out for our use-case. The second option is to setup an additional service like where your services register on start-up. Discovering a service is then simply a query to this additional service. But wait, how does your original service know where Zookeeper is located? We face the good old here. While there are surely ways to solve this problem they didn’t satisfy us. Additionally, Zookeeper becomes a single point of failure in this solution. Apache Zookeeper chicken-and-egg In the realm of AWS, there is a third alternative: use AWS itself for service discovery. AWS is actually single point of truth knowing which of your services/machines/lambdas/you-name-it are up and running. With the we can easily ask how to reach these instances. Additionally, there is no single point of failure. Well, of course AWS could be down (or at least their endpoint for API queries). But then we probably have to escape to another region anyways. the AWS SDK Although this solution seems to be obvious when you think about it. You hardly find this advice in the Stack Overflow literature. Configuration hell So the idea was to write a thin layer around the AWS SDK. But how should we expose the functionality to our clients? A good API is always nice, but not really useful when it comes to service discovery. You usually don’t want to hard-code the components with all filters in your code directly. Your discovery probably is very different in your local dev-environment then in your CI test-environment. Which, in turn, is different to staging and production. Hence, service discovery itself should be configurable via a simple configuration file. Now, configuration syntaxes usually get it wrong somehow. You either have way too many options making the whole thing unusable unless you are the library maintainer yourself. Or you have just a handful of options which lets you accomplish simple tasks quite easily, but as soon as it gets more complex the library comes to its limit. Service discovery is especially tricky. You want some kind of domain-specific language (DSL) which makes it easy to define the objects you want to discover, the constraints they should satisfy and what attributes of the objects you actually need. Anyways, developing good DSLs is a hard task. So we looked around for existing solutions that could fill the gap somehow. The answer we found might be surprising: . GraphQL was initially developed by Facebook and got publicly released in 2015. Several implementation exist for a huge set of languages –for Scala there is . GraphQL is a simple query language leaning towards a JSON-style syntax. You might rather know it as an alternative to REST when developing HTTP APIs. Well, we use it for something different here. GraphQL Sangria Examples, please! To see how GraphQL works, let’s right jump into an example. Let’s say you want to discover EC2 instances with their id and private IP addresses: query {ec2Instances {idprivateIpAddress}} This is all very clean and clear. This is how an answer formatted in JSON looks like: {"data" : {"ec2Instances" : [{"id" : "i-5bc9450cebf76ff90","privateIpAddress" : "172.18.42.252"},{"id" : "i-48eb0089ee2cf0324","privateIpAddress" : "172.18.17.226"},{"id" : "i-f54ee382cf9e1f773","privateIpAddress" : "172.12.57.132"}}}} See how only the attributes we requested (namely and ) are returned? That's actually the outstanding feature and elegance of GraphQL. id privateIpAddress How about adding a filter because you only want the machines which are called and : midas-rocks midas-is-awsome query {ec2Instances(filters: [{name: "tag:Name",values: ["midas-rocks", "midas-is-awsome"]}]) {idprivateIpAddress}} This didn’t become too complicated, right? The filters get simply mapped to argument. Hence you can actually use all the . The output of this query would be similar to the one listed above, but only containing the machines with the right names. AWS’s Filter documented filters Now, for something more complicated: ECS. If you want to discover where your service is running on ECS, you’ll have to discover the EC2 instance it runs on. (Don’t know if that is going to change with Fargate.) To get all EC2 instances which are part of your ECS cluster you’d use: query {ecsClusters {tasks {containerInstance {ec2Instance {privateIpAddress}}}}} Again, there is a filter for almost every query-level. If, for example, you’d wanted to fetch only the cluster whose ARN ends in and in this cluster you just want the instances running the tasks belonging to the family: cluster/my-test-cluster foobar query {ecsClusters(filterArn: ".*cluster/my-test-cluster") {tasks(family: "foobar") {// ...}}} The former query would yield a result like this: {"data" : {"ecsClusters" : [{"tasks" : [{"containerInstance" : {"ec2Instance" : {"privateIpAddress" : "172.18.42.252"}}},{"containerInstance" : {"ec2Instance" : {"privateIpAddress" : "172.18.17.226"}}}]}]}} Things become a bit more complicated here and there is quite some work involved if you wanted to extract the interesting bits from this example. Also, as indicated above, the query will be defined in a configuration file. So, in your code you don’t have any clue how to map into this structure in order to get to the interesting parts. This is where extractors come into the game. Extractors hook into Sangrias mechanism which provide a way to step through the query in an early preparation step. We use it to generate a query-tailored function which extracts just the fields from the result of the query. Let’s see how that works interactively: query reducers scala> import scala.concurrent.Awaitscala> import scala.concurrent.duration._scala> import scala.concurrent.ExecutionContext.Implicits.globalscala> import sangria.macros._scala> val query = graphql"""| query {|   ecsClusters {|     tasks {|       containerInstance {|         ec2Instance {|           privateIpAddress|         }|       }|     }|   }| }| """query: sangria.ast.Document = // [...] scala> import social.midas.discovery.commonscala> val fut = common.prepareQuery(|   query, extractors=List(common.Ip4Extractor),| )fut: scala.concurrent.Future // [...] scala> val prepared = Await.result(fut, 10.seconds)prepared: sangria.execution.PreparedQuery // [...] scala> val extractor = prepared.userContext.extractor.getextractor: Any => Seq[Any] = // [...] scala> val result = Await.result(prepared.execute(), 10.seconds)result: Any = // [...] scala> extractor(result).asInstanceOf[Seq[String]]res0: Seq[String] = Vector(172.18.42.252, 172.18.17.226) “Dude, this is too complicated!” Of course, this is all way too complex. So there is an overall wrap-up function which reads the query and the extractor from a configuration file and delivers the final result in a : Future scala> Await.result(common.discoverFromConfig(), 2.seconds)| .asInstanceOf[Seq[String]]res3: Seq[String] = Vector(172.18.42.252, 172.18.17.226) We use the . This is how the configuration file looks like: config library by Lightbend discovery.aws.region = "eu-central-1"discovery.extractors = [ "social.midas.discovery.common.Ip4Extractor$" ]discovery.query = """query {ecsClusters {tasks {containerInstance {ec2Instance {privateIpAddress}}}}}""" In our main routine we then simply call and get all the IP addresses of the EC2 instances being part of our ECS cluster. discoverFromConfig What it is and what it isn’t. Don’t expect a fully fledged library which discovers all kinds of services exactly on AWS! The library, as of this writing, only supports the discovery of IP4 addresses on EC2 and ECS. Yet it is under heavy development. While we don’t expect the API to change dramatically there surely is space for improvement. Mainly you can expect discoverable services and extractors to grow rapidly in the near future. After all, we open sourced this piece of software to get your feedback. We think that the proposed solution to wrap the AWS SDK in a query language like GraphQL is elegant and outstanding when it comes to the task of service discovery. Tell us what you think about it. We’d love to hear from you!

Midas Open Sources its Service Discovery Library

In different post in the past, we have explorer why is testing so important to us. Also, we took a look at ScalaCheck, a Property Based Testing Framework for the Scala programming language. Because we are explorers, we have started a new adventure, creating a small, yet functional and easy to use Property Based Library to be used in .NET based languages. Motivation We want a library that works with our current testing framework, in our case, xUnit. By doing a quick look at NuGet, we can find some frameworks that target the same space that ours, but they required learning the entire framework. Also, you might need to give up your favorite testing framework in order to use it. Many other problems rise from this such as having a test runner for your IDE, etc…. Our library is not intended to change anything that we do today, but instead, allows us to use property based testing along our regular tests. Core Concepts The most import piece is what we call and it represents a way to generate data of type T. Gen<T> bounded The most simple generator can be created in the following way: gen = Gen< >.Empty(); var int Assert.Empty(gen.Generate()); Notice that we are using so we are not introducing any assertion API at all. xUnit.Assert Now, let’s look at some other ways to create generators. A single item generator once = Gen< >.Once(5) var int Assert.Single(Gen< >.Once(5).Generate()); int Repeat generator repeat = Gen< >.Repeat(5, 20); var int Assert.True(repeat.Generate().Count() == 20);Assert.True(repeat.Generate().ToList().TrueForAll(x => x == 5)); In here, we are saying that we want to generate the value as many as times. 5 20 Important to notice is that calling will always return the same dataset. .Generate() Enumerable generator A more interesting generator is the one created from . IEnumerable<T> enumerableGen = Gen< >.FromEnumerable(Enumerable.Range(1, 100)); var int Assert.True(enumerableGen.Generate().Count() == 100); A simple version can be generated by doing: enumerableGen = Enumerable.Range(1, 100).ToGen(); var Assert.True(enumerableGen.Generate().Count() == 100); Generators by itself cannot do much. However, the idea is to use them as value generators in order to test some properties on them. Producers Many times we need a more robust way to generate data. A ’s intend is exactly that. Producer IProducer< T> : IEnumerable<T>{ public interface out } As you can see, is only a way to generate a sequence of values of the same type . IProducer T A simple for generating ** **s could be: Producer int IntProducer : IProducer< >{ IEnumerator< > GetEnumerator(){ ( ){ Random().Next();}} public class int public int while true yield return new IEnumerator IEnumerable.GetEnumerator()  
{  
    **return** GetEnumerator();  
} } It is important to notice that generates a collection of ) from the so we can force bounds on it. IntProducer unbounded int s. We need to obtain a generator ( Gen<T> Producer We can use the following to do so: intGenerator = ( IntProducer()).ChooseFrom() var new By applying to any we create a which forces bounds on the . .ChooseFrom(howMany) Producer Gen<T> Producer Another example could be : StringProducer StringProducer : IProducer< >{ IEnumerator< > GetEnumerator(){ ( ){ Random().Next().ToString();}} public class string public string while true yield return new IEnumerator IEnumerable.GetEnumerator()  
{  
    **return** GetEnumerator();  
} } Again, we could get a from it by doing: Gen<T> stringGenerator = ( StringProducer()).ChooseFrom(20) var new We also included a way to generate tuples of the form by using . (T, K) TupleProducer<T, K> TupleProducer<T, K> : IProducer<(T, K)>{ IProducer<T> ; IProducer<K> ; public class private readonly _tProducer private readonly _kproducer **public** TupleProducer(IProducer<T> tProducer, IProducer<K> kproducer)  
{  
    **\_tProducer** \= tProducer;  
    **\_kproducer** \= kproducer;  
}  
  
**public** IEnumerator<(T, K)> GetEnumerator()  
{  
    **var** tenum = **\_tProducer**.GetEnumerator();  
    **var** kenum = **\_kproducer**.GetEnumerator();  

    **while** (tenum.MoveNext() && kenum.MoveNext())  
    {  
        **yield return** (tenum.**Current**, kenum.**Current**);  
    }  
}  

IEnumerator IEnumerable.GetEnumerator()  
{  
    **return** GetEnumerator();  
} } Once more, we can get a generator from it using . .ChooseFrom ForAll & Any Once we have created a generator we can use and as existential quantification to proof that a property holds for the values being generated. .ForAll .Any Let’s look at some examples by testing the following functions: id< >( x) => x; T T T sqrt( x) => x * x; int int concat( a, b) => a + b; string string string Notice this is perfectly valid code, here we are only using method body syntax, the equivalent in a more traditional will be: C# C# id< >( x) { T T T x;}... return Let’s move forward to test these functions. [Fact] Identity(){Assert.True(( IntProducer()).ChooseFrom().ForAll(x => id(x) == x));} public void new receives the statement we want to state about the values. .ForAll In the case of , we want to proof that . Identity for all x, id(x) == x The property will be evaluated for every single value on the generator. Now, let’s test sqrt: [Fact] SomeSquares(){Assert.True(Gen< >.FromEnumerable(Enumerable.Range(1, 100)).Any(x => sqrt(x) == x));} public void int In this case, the property is only valid for the value . Since we are using the test is also a passing test. It is enough that the property holds for at least one value when we are using . sqrt(x) == x 1 .Any .Any Finally, we can test . concat [Fact] Concat(){ stringProducer = StringProducer(); producer = TupleProducer< , >(stringProducer, stringProducer); public void var new var new string string producer.ChooseFrom().ForAll(t =>concat(t. , t. ).StartsWith(t. )&&concat(t. , t. ).EndsWith(t. )).Should().BeTrue();} Item1 Item2 Item1 Item1 Item2 Item2 This one is very interesting since we are using the and together. StringProducer TupleProducer In here, we generate random strings, concat them together and proof the property: . Our library will choose 100 strings (bounded collections or ) produced by the and test that the property holds for all of them. for all a, b that are string, a + b == a* && a + b == *b Gen<T> StringProducer Notice we are doing the assertions through the FluentAssertion API instead of simply Assert . However, it is just to show that our library is not limited to one testing framework or assertion style. Endings Even though this is a very small library, it does its job well and allows us to bring a simplified property based testing to . .net you can start using it today by getting it from the NuGet Gallery. PM> Install-Package NetChecker -Version 1.0.0 Contributions are always welcome on the GitHub NetChecker Project . If you want to learn more about Property Based Testing you can read Exploring Property-Based Testing with ScalaCheck (simple examples)

.NET Minimalist Property Based Library

If we travel back in time, android development meant Java development. Though there were few other languages to develop android application like Scala, C++, Lua however none of them could stand against Java. But now whenever we think of android development, Kotlin hits the head.Other languages fought Java from outside but Kotlin had a centuries old strategy, they did same as Greeks did centuries back. Guardians of the android were defeated with the greatest strength of Kotlin, interoperability. It stands beside Java, fighting against Java to rule Android. is one of the greatest strength of kotlin. Kotlin programs can use all existing Java frameworks and libraries even advanced frameworks that rely on annotation processing. It is just plug and play easy. Interoperability once your android studio project is configured to support Kotlin, you’ll even be able to convert an entire Java source file into a Kotlin file, with just a few clicks of your mouse. Setup is super easy, because it is super easy to learn and when you’re done with it. Less code, less time, less bugs, less human errors. You can have lot of time for yourself. Me time :) It is source of happiness which is easier to maintain. Kotlin cuts down the boilerplate code, the scary click listeners, find views by ids. I still remember when my manager asked me for code review, he stopped by the boilerplate code asking me why I write all this mess, making the code unreadable. Cleaner code view.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {// Java the messed up code}}); view.setOnClickListener {// Write in kotlin} is one of the most awaited thing. Android apps often had to suffer and publish a new version if any key in web api is renamed or removed. I always envied iOS developers sitting back and relaxing while me preparing another version. Well it’s time to relax. Kotlin is to rescue. Null Safety There are lots of reasons to try Kotlin but one is my favorite. It is free of cost, you don’t need another IDE, and you don’t need another project. It’s new and is here for rescue. You can start by writing simple and small parts of your app getting familiar. It is super easy by the way ;) Why not??? Kotlin application runs as fast as an equivalent Java one, thanks to very similar bytecode structure. With Kotlin’s support for inline functions, code using lambdas often runs even faster than the same code written in Java. Kotlin has a very compact runtime library, which can be further reduced through the use of ProGuard. Kotlin supports efficient incremental compilation, so while there’s some additional overhead for clean builds, incremental builds are usually as fast as or faster than with Java. Kotlin has been successfully adopted by major companies, and a few of them have shared their experiences**;** Oh well that happens sometimes when you’re in habit of writing code in Java, you often end up putting semicolons even when not needed. This won’t happen if you code in Kotlin :)Happy coding. Android is happy with KOTLIN

The secret of KOTLIN success and why should you use it?

Why didn’t Lambda ship Docker out of the box? Is it because of security concerns? Why even bother, let’s do it ourselves! Lambda is pioneering the serverless market. Look at the chart below: 🤔 What happened on Jan 8th? I know, it’s just search activity. But you can see how much ahead of time it was in 2015. Monopoly isn’t good for the end user. No competition = stagnating development. A year later Azure popped up with function bindings & Logic Apps. Google revealed simpler dependency management and nice dashboard. And recently I discovered . This is an open-source alternative to run your own serverless platform. And unlike everything else, it can run functions from Docker images you supply. Apache OpenWhisk Docker for Serverless? What’s the Point? You may ask, . Sure, but the reality is it’s not always that simple. “Why complicate? Why Docker? Serverless is about simple functions.” No more **zip** The entire world shifted to containers, and now AWS tells you to pack all your code with dependencies into 1 zip. A step back IMHO. ¯\_(ツ)_/¯ With Docker you build functions in the same way as you did for years with microservices. Arbitrary binaries Ever wanted to use , , or any other binary in your functions? Launch EC2 instance with a specific version of Amazon Linux, compile binaries, squeeze everything under 50MB and you’re good to go! bcrypt phantom.js ffmpeg Small tip: if binary is too big, you can download it at the runtime to . Network speed is fantastic, but watch out for cold start overhead. /tmp With Docker you would throw it in Dockerfile and let the magic happen. Write in any language As for June 2017 officially supported are: Node.js, Python, Java (Groovy, Scala), C#. Unofficially: , , , , , , and some others. Go Closure PHP Ruby Haskell Swift F# Using unofficial language is cumbersome, similarly to compiling binaries. With Docker it’s simple as . FROM brainfuck:latest No vendor lock-in It’s a plain docker image with your code inside. Sure, there is some custom logic which rely on FaaS API, but I feel better already. With Docker it doesn’t matter where do you — Google or OpenWhisk. docker pull How Hard Is It? Okay, so enough theory. I hope you share some of my excitement now. To begin with, I need to know what kind of environment Lambda is running in. I want to look around, try things to see is it possible to run docker daemon there. For my experiments I used a handy tool called from . lambdash Eric Hammond Did you know Eric is AWS Community Hero? officially You can run any command there. Seriously, check it out. So I started playing with absurd commands a-la and so on. No surprise it didn’t work out. sudo apt-get install docker Then I tried to install Docker from . Downloading and unpacking went fine, unless I tried to start it. Docker needs root access to start a daemon 😓. Of course it’s not available in such a limited environment as Lambda. static binaries So how much is it limited? 128 to 1536 MB of RAM (and a proportional amount of CPU) 0.1s to 300 seconds of execution time 512 MB of writeable disk space under /tmp 250 MB of deployed code with dependencies (but 50 MB zipped) NO ROOT ACCESS No sudo. Is it still possible to run Docker? My brain replied , but heart was telling “NO” “GO RESEARCH, VLAD”. So I did the research. What are the options? Use . This library wraps Docker Remote API to spawn arbitrary docker containers outside of Lambda dockaless Forget this stupid idea 1st option is not truly “serverless”. It requires some real servers running. So I was about to choose 2nd, unless one random day I found . udocker Only 117 stars on GitHub. This gem deserves more! Execute docker containers without root privileges. This is insane. Needles to say this project concluded my success. These smart guys figured out you can unpack docker image and execute it in an emulated environment. Well done. Straight to the Code You can find all the code on . But before some disclaimers: GitHub uses as execution engine by default. It will not work in Lambda. udocker PRoot Luckily, there is a which allows you to choose one from 3 available execution engines. development branch Lambda has 512 MB of disk space. No gigantic Docker images. You need to download udocker and docker image on every Lambda cold start (roughly every 4 hours, ). It may take some seconds. proof Installation In Lambda, the only place you are allowed to write is . But udocker will attempt to write to the homedir by default. I need to change its mind. /tmp HOME=/tmp UDOCKER_DIR=/tmp UDOCKER_BIN=/tmp UDOCKER_LIB=/tmp UDOCKER_CONTAINERS=/tmp export export export export export Voilà. You home is in /tmp now. Do whatever you want. Next, let’s download udocker python script. $ /tmp$ https://raw.githubusercontent.com/indigo-dc/udocker/udocker-fr/udocker.py > udocker$ udocker version cd curl python If everything went well, you’ll see something like: Info: creating repo: /tmpInfo: installing from tarball 1.1.0-RC2Info: downloading: https://owncloud.indigo-datacl... udocker 1.1.0-RC2 I show only code did I run. You choose to run it. I used for the sake of simplicity. You may want to spawn a script from Node.js/Java/Python code you write for your functions. what how lambdash Setting up & Running Ubuntu This will download image from Docker Hub to your /tmp. $ udocker pull ubuntu:17.04 python Next step is important. You need to create a container AND set up the execution engine mode. Since PRoot isn’t working in Lambda ( ), I tried the second option. bug Plenty of options to choose, not sure what all they mean. Help me, linux experts. $ udocker create --name=ubuntu ubuntu:17.04$ udocker setup --execmode=F1 ubuntu python python Finally, hold your breath and run it. $ udocker run --nosysdirs ubuntu cat /etc/lsb-release python DISTRIB_ID=UbuntuDISTRIB_RELEASE=17.04DISTRIB_CODENAME=zesty DISTRIB_DESCRIPTION="Ubuntu 17.04" That’s all. This is a small proof of concept. But you got the idea. Go and experiment with images and tell me what you think in the comments below. This Isn’t a Good Idea. But It Was Fun to Build It’s pain in the ass. Downloading udocker with docker image every 4 hours. Sacrificing startup time. Clog your /tmp up to 100% and so on. (Not anymore, read UPD below). But possible if you have a specific use-case. Who knows, maybe this post will facilitate the native Docker support from AWS (#awswishlist I am looking at you). I believe it will inspire community to build next crazy ideas. Like these folks inspired me: _Finally proof that serverless has servers?_medium.com SSH-ing into your AWS Lambda Functions _An adventure in getting Chrome (read: Chromium) to run “serverless-ly” from compiling it to deploying it on AWS Lambda._medium.com How to get headless Chrome running on AWS Lambda P.S. Thanks for reading. Click 💚 and subscribe if you want more ;) has developed a framework implementing similar ideas of running Docker in Lambda! P.P.S. UPD: A month before this post, Germán Moltó Meet the — Serverless Container-aware ARchitectures! SCAR _scar - Serverless Container-aware ARchitectures (e.g. Docker containers in AWS Lambda)_github.com grycap/scar

How Did I “Hack” AWS Lambda to Run Docker Containers

Recently, I built a lightweight task scheduler on top of in Go. The application schedules batch jobs with custom arguments and schedules as single containers via AWS ECS, an orchestrator built on top of EC2 and Docker. One of the key requirements of the scheduler is monitoring the status of actively running tasks. For this, I chose to use AWS ECS’s endpoint, which takes ECS task ID(s) and returns their status, exit code if complete, reason for stopping, etc. AWS ECS DescribeTasks Due to rate limits, I had to batch API calls. Initially, I thought my code would look something like this — Seems reasonable, right? The scheduler just has to create a monitor, submit tasks via , and poll until the target task is complete. Watch GetStatus … Sorta. The first problem with is the scheduler must know the monitor is batched since it returns a map of all tasks to their status. Exposing implementation details in an API is generally a sign of a leaky abstraction. GetStatus Take #2— Great! Now, returns a status given a task. Though just a few extra characters, this is a huge usability improvement since the scheduler no longer needs to batch tasks. GetStatus However, there’s still a problem with this code. When should scheduler call ? In a loop, of course! GetStatus That works, but it’s not elegant and less than ideal for more expensive operations. We can do better. If you came to Go from JavaScript, Scala, C#, or another language with Promises/Futures, you’re probably thinking “How do those translate to Go?”. Well, Go doesn’t have “futures” per se, but it also doesn’t them because channels are so powerful. Let’s take a peek! need This is beautiful, efficient, and way simpler. returns a channel, which is “await”-able. Boom! monitor.Watch(task) Using channels as in Go isn’t perfect. First, it’s not possible to make a library around them with helper functions as seen in , for example, due to Go’s lack of generics. Also, creating a channel for every call is not space-efficient, as each channel has its own mutex, buffer, etc., so this isn’t the right decision if you’re dealing with lots of calls in a performance-intensive application. In those cases, you should use a single channel and reader, e.g. futures Bluebird function … but that comes with more indirection so try out channels as futures when possible (most use cases) for a readable, straight-forward API! If you found this interesting, consider following me on , where I share my experiences with Go amongst other things. Twitter is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising &sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

Using Channels as Futures in Golang

In mathematics and computer science, a higher-order function (also functional, functional form or functor; not to be confused with the functor concept in category theory) is a function that does at least one of the following: 1. takes one or more functions as arguments, 2. returns a function as its result. That is the formal definition, but what really are they and why do we need them? Sometimes, it is important to execute some kind of operation on the items of a dataset, but this particular operation is defined at execution time. Sometimes there is just no way to know what action we want to take except that we need to do something at some particular point, but it is completely unknown. Let’s see an example. let x = [1..100] for each item in x doprint(item) Here, we are printing the each number in the list x by calling the function print. What about if we need to do something else with each item? Do we need to implement all possible cases that we think we will use? Let’s define a that will be called for each number (item) in x. function let succ (x) -> x + 1 We have defined the function which basically gets a value and returns its successor. The domain of is the Int numbers and that can be inferred from the body of since we are adding 1 to the argument and we say that has type successor succ succ succ Int -> Int. Now, let’s review the previous example. let map (f, list) =for each item in list dof(item) Here, is a higher order function because it received a function as an argument, which will be executed on each item from list. At the moment we define we don’t need to know what will be the value of , except that as type . There is no way to infer the return value of from the previous code, but we know it has to receive an . map f map f f Int -> Some f Int Another example will be a function that returns another function. Let’s review it. let plus2 (x) =let succ (y) = y + 1 succ (succ x) let r = plus2 (1) In this case is a function of type or . It basically takes an and returns a function that takes another and returns an . will be equals 3 after evaluation. plus2 Int -> Int -> Int Int -> (Int -> Int) Int Int Int r Now that we have shown how these kinds of functions are, let’s see how modern programming languages define them. In we can define a function of type as follow: Scala map (a -> b, List[a]) -> List[b] def map[a,b](f: a => b, v: List[a]): List[b] = {for ( i <- v )yield f(i)} val squares = map( (x: Int) => x * x, 1.to(100).toList ) For each in we apply the function and return its value. The variable squares will have the squares values of the numbers from 1 to 100. Please note that we are defining the function at the moment we call , so doesn’t know anything about the function . We can easily say: i v f squared map map f def succ (x: Int): Int = x + 1 val successors = map(succ, 1.to(100).toList) We just changed the function passed to and we get a completed different result. This level of abstraction is what makes , as a higher order function, very powerful. map map Even programming languages that are not functional, such as , have added these abstractions so they can be flexible to many use cases. C# In we need to implement a in order to get the same functionality, but it brings the same value to the language. Because higher or functions are so important, the .NET Framework has some already implemented, so let’s use them C# delegate delegates List<b> map<a>(Func<a,b> f, List<a> list){foreach (a x in list){yield return f(x);}} var successors = map(x => x + 1, someIntList); We have achieved the same functionality of the in . The only different is that does not have higher order functions and it has to use the constructs, yet we get the same functionality as result. Note that in there is no need to declare the type of the arguments of the function when we pass it to , infers it! map Scala C# delegates C# succ map C# In is where it gets very interesting because the language support to the functional programming (FP) paradigm. In we do: F# F# let map f = function|[]     ->[]|h::t   -> (f h) @ (t |> map f) let successors = [1..100] |> map (fun x -> x + 1) Seems complicated, but it is in fact the same we saw previously. The only additions are the functional programming style and the tail recursion, typical of functional programming languages. The pipe operator is just a language construct, we might say instead or . Note that the type inference system works quite nice in . We have not defined any types; however, is inferred to receive a function and a list and returns a list. map |> map f t map (fun x -> x + 1) [1..100] F# map transformed The function in will be as follow: plus2 F# let plus2 x =let succ y = y + 1succ succ y For some people, higher order functions are common in their lives. These functions are built in within many languages and frameworks; still, I have seen some confusion around them. Languages that do not support them need to find alternatives that sometimes are not easy to use and implement. The language uses pointers to functions, uses and others use objects as substitutes. On the other hand, there are those that support higher order function out of the box. , , and are just a few examples. C C# delegates Scala Python F# Even though sometimes we use these functions without thinking much about them, we should be aware of how they are implemented so we can benefit even more from them. Those who are new to this programming construct we inherited from the calculus should study them and get familiar around them since the trend of functional programming seems to be gaining some battles. Higher order functions are some of the pillars of the FP languages and that seems to be the future. lambda is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising &sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

Higher order functions, what are they?

Future-Proof Your App: Scalability Considerations for Long-Term Success

ভবিষ্যত-প্রুফ আপনার অ্যাপ: দীর্ঘমেয়াদী সাফল্যের জন্য স্কেলেবিলিটি বিবেচনা

Machen Sie Ihre App zukunftssicher: Überlegungen zur Skalierbarkeit für langfristigen Erfolg

Prepare su aplicación para el futuro: consideraciones de escalabilidad para el éxito a largo plazo

Pérennisez votre application : considérations d'évolutivité pour un succès à long terme

अपने ऐप को भविष्य के लिए तैयार करें: दीर्घकालिक सफलता के लिए स्केलेबिलिटी पर विचार करें

将来を見据えたアプリの構築: 長期的な成功のためのスケーラビリティの考慮

미래 지향적인 앱: 장기적인 성공을 위한 확장성 고려 사항

Prepare seu aplicativo para o futuro: considerações de escalabilidade para sucesso a longo prazo

Готовность вашего приложения к будущему: соображения масштабируемости для долгосрочного успеха

Uygulamanızın Geleceğe Hazırlanması: Uzun Vadeli Başarı için Ölçeklenebilirlik Konuları

Chứng minh ứng dụng của bạn trong tương lai: Những cân nhắc về khả năng mở rộng để đạt được thành công lâu dài

让您的应用经得起未来考验：长期成功的可扩展性考虑因素

I remember the day one of my good friends reached out and asked if I had heard about Nuklai. I simply told him, “Not really. That sounds like a topic I would study in my science class.” Fast forward six months, and here I am, building a Layer 1 blockchain network for Nuklai. Who would’ve thought? It is amazing where life takes you in a matter of months. I will get to the core of this blog about my journey into the world of HyperVMs, but before that, it is essential to know how I even got to this point. The Challenge of High Throughput Soon after I heard about Nuklai, I started to research the project to see what all the hype was about. I was really blown away by Nuklai’s vision to empower every user by allowing them to sell their data to other entities, shifting the power from big businesses to the users themselves. It is a simple yet profound vision because, to achieve it, much had to be done not just at the application level but also at the infrastructure and blockchain protocol levels. When dealing with massive amounts of data daily, the blockchain must handle an immense load that no current platform has achieved yet. People talk about Transactions Per Second (TPS), but few know what it truly takes to achieve such high TPS at the blockchain level. Yes, there are blockchains out there with high throughput, but often, they are very hacky and not true Layer 1s. Usually, the approach is to scale horizontally by creating Layer 2s, Layer 3s, sidechains, and whatnot. These solutions feel like patchwork to me because if you introduce an additional layer to your blockchain, increasing the TPS seems more like an afterthought than something built from the ground up. This is where HyperVMs come into play. HyperVMs, Unlocking High-Performance Blockchains But, what is a HyperVM? It’s essentially a virtual machine (VM) built using the HyperSDK framework. To understand HyperSDK, we first need to understand Avalanche. According to their documentation, Avalanche is an open-source platform for building decentralized applications in one interoperable, decentralized, and highly scalable ecosystem. Powered by a uniquely powerful consensus mechanism, Avalanche is the first ecosystem designed to accommodate the scale of global finance, with near-instant transaction finality. The Avalanche consensus mechanism is ridiculously fast, with less than 2 seconds of finality, meaning your transaction is processed and verified almost instantly. Avalanche also allows you to create your own Layer 1 blockchain (or subnet), and the best part is you are not confined to an Ethereum Virtual Machine (EVM) powered subnet. Despite its large developer community, the EVM is not lightweight and comes with a lot of baggage. On Avalanche, you can also launch your own subnet by developing your own VM in any language as long as it conforms to Avalanche’s Proto interfaces. This is where HyperSDK comes into play. Theoretically, you could build your own VM in any language you want, as Avalanche provides that freedom. However, it is also true that it is rather difficult and time-intensive to do from scratch. Even if you use Subnet EVM to get started, it is complex to keep it up-to-date as the core code changes frequently. You need to keep up with maintaining it, which can become resource-intensive. HyperSDK addresses this issue by making it faster, safer, and easier to launch your own optimized blockchain on an Avalanche subnet. It hides much of the complexity, allowing you to focus on making your project unique rather than worrying about transaction serialization efficiency or increasing transaction throughput. With HyperSDK, you can build your own blockchain runtime with 500-1000 lines of code and still process thousands of transactions per second without needing a large team of engineers. HelixVM: The 100,000 tx/s Powerhouse? At Nuklai, we built our own blockchain runtime, called ‘HelixVM,’ using the HyperSDK framework with around 200 lines of code in under a week. We added exciting features such as natively issuing tokens, bridging tokens from one subnet to another using Avalanche Warp Messaging (AWM), and developing a staking engine that lets validators register for staking and users delegate their NAI tokens to a validator of their choice to start claiming rewards. With some more additions and custom touches, we added everything with around 500 more lines of code in a couple of months. The journey to get here was extraordinary but equally rewarding. The best part about building our runtime using HyperSDK is that we benefit from the optimizations that come to the HyperSDK framework, worked on by some of the best engineers from Ava Labs and the wider open-source HyperSDK community. For example, with the development of HyperSDK Vryx, which recently produced exceptional results with HyperVMs processing over 5 billion transactions at 100,000 transactions per second, once our HelixVM supports Vryx, it will also process 100,000 transactions per second. This is the true hidden power of using HyperSDK to build your own blockchain runtime    Achieving this level of optimization without having to do it ourselves makes it a no-brainer for any team to build their own runtime as well. At Nuklai, we want to build a platform that lets users and businesses monetize their data as easily as building a website, and HyperSDK is the ultimate base layer to achieve that without worrying about how the consensus engine works. We want to build a unique platform that suits our needs, and HyperSDK makes it possible with just a few hundred lines of code. Build the Future of Smart Data With Nuklai Testnet Recently, we released our Nuklai testnet. It only took a few months to get here, and we have many exciting features planned for our HelixVM before the mainnet release, coinciding with HyperSDK’s own roadmap of being production-ready. If you want to get started with our testnet, check out the Nuklai Wallet repository, clone it locally, run it, and start interacting with the testnet. You can request test NAI tokens, create your own tokens, transfer native NAI and other user-created tokens, explore a basic version of the blockchain explorer, and even post something to Nuklai Feed - a simple social media platform. Additionally, the wallet lets you change the Nuklai RPC URL, allowing you to connect to your own Nuklai subnet running locally on your machine. You can watch the demo, and get started today! If you prefer running your own Nuklai subnet locally instead of interacting with the official testnet, you can follow the directions outlined in our documentation. This allows you to do more, such as registering validator nodes for staking, delegating to validators, claiming staking rewards, and more. Welcome to the future where you can move a mountain with your fingers! Written by Kiran Pachhai, Lead Blockchain Architect at Nuklai I remember the day one of my good friends reached out and asked if I had heard about Nuklai . I simply told him, “Not really. That sounds like a topic I would study in my science class.” Fast forward six months, and here I am, building a Layer 1 blockchain network for Nuklai. Who would’ve thought? It is amazing where life takes you in a matter of months. Nuklai Nuklai I will get to the core of this blog about my journey into the world of HyperVMs, but before that, it is essential to know how I even got to this point. The Challenge of High Throughput Soon after I heard about Nuklai, I started to research the project to see what all the hype was about. I was really blown away by Nuklai’s vision to empower every user by allowing them to sell their data to other entities, shifting the power from big businesses to the users themselves. It is a simple yet profound vision because, to achieve it, much had to be done not just at the application level but also at the infrastructure and blockchain protocol levels. When dealing with massive amounts of data daily, the blockchain must handle an immense load that no current platform has achieved yet. People talk about Transactions Per Second (TPS), but few know what it truly takes to achieve such high TPS at the blockchain level. Yes, there are blockchains out there with high throughput, but often, they are very hacky and not true Layer 1s. Usually, the approach is to scale horizontally by creating Layer 2s, Layer 3s, sidechains, and whatnot. These solutions feel like patchwork to me because if you introduce an additional layer to your blockchain, increasing the TPS seems more like an afterthought than something built from the ground up. This is where HyperVMs come into play. HyperVMs, Unlocking High-Performance Blockchains But, what is a HyperVM? It’s essentially a virtual machine (VM) built using the HyperSDK framework . To understand HyperSDK, we first need to understand Avalanche . HyperSDK framework HyperSDK framework Avalanche Avalanche According to their documentation, Avalanche is an open-source platform for building decentralized applications in one interoperable, decentralized, and highly scalable ecosystem. Powered by a uniquely powerful consensus mechanism, Avalanche is the first ecosystem designed to accommodate the scale of global finance, with near-instant transaction finality. Avalanche is an open-source platform for building decentralized applications in one interoperable, decentralized, and highly scalable ecosystem. Powered by a uniquely powerful consensus mechanism, Avalanche is the first ecosystem designed to accommodate the scale of global finance, with near-instant transaction finality. The Avalanche consensus mechanism is ridiculously fast, with less than 2 seconds of finality, meaning your transaction is processed and verified almost instantly. Avalanche also allows you to create your own Layer 1 blockchain (or subnet), and the best part is you are not confined to an Ethereum Virtual Machine (EVM) powered subnet. Despite its large developer community, the EVM is not lightweight and comes with a lot of baggage. On Avalanche, you can also launch your own subnet by developing your own VM in any language as long as it conforms to Avalanche’s Proto interfaces . This is where HyperSDK comes into play. Proto interfaces Proto interfaces Theoretically, you could build your own VM in any language you want, as Avalanche provides that freedom. However, it is also true that it is rather difficult and time-intensive to do from scratch. Even if you use Subnet EVM to get started, it is complex to keep it up-to-date as the core code changes frequently. You need to keep up with maintaining it, which can become resource-intensive. HyperSDK addresses this issue by making it faster, safer, and easier to launch your own optimized blockchain on an Avalanche subnet. Subnet EVM Subnet EVM It hides much of the complexity, allowing you to focus on making your project unique rather than worrying about transaction serialization efficiency or increasing transaction throughput. With HyperSDK, you can build your own blockchain runtime with 500-1000 lines of code and still process thousands of transactions per second without needing a large team of engineers. HelixVM: The 100,000 tx/s Powerhouse? At Nuklai, we built our own blockchain runtime, called ‘HelixVM,’ using the HyperSDK framework with around 200 lines of code in under a week. We added exciting features such as natively issuing tokens, bridging tokens from one subnet to another using Avalanche Warp Messaging (AWM), and developing a staking engine that lets validators register for staking and users delegate their NAI tokens to a validator of their choice to start claiming rewards. With some more additions and custom touches, we added everything with around 500 more lines of code in a couple of months. The journey to get here was extraordinary but equally rewarding. The best part about building our runtime using HyperSDK is that we benefit from the optimizations that come to the HyperSDK framework, worked on by some of the best engineers from Ava Labs and the wider open-source HyperSDK community. For example, with the development of HyperSDK Vryx , which recently produced exceptional results with HyperVMs processing over 5 billion transactions at 100,000 transactions per second, once our HelixVM supports Vryx, it will also process 100,000 transactions per second. This is the true hidden power of using HyperSDK to build your own blockchain runtime Achieving this level of optimization without having to do it ourselves makes it a no-brainer for any team to build their own runtime as well. At Nuklai, we want to build a platform that lets users and businesses monetize their data as easily as building a website, and HyperSDK is the ultimate base layer to achieve that without worrying about how the consensus engine works. HyperSDK Vryx HyperSDK Vryx We want to build a unique platform that suits our needs, and HyperSDK makes it possible with just a few hundred lines of code. Build the Future of Smart Data With Nuklai Testnet Recently, we released our Nuklai testnet . It only took a few months to get here, and we have many exciting features planned for our HelixVM before the mainnet release, coinciding with HyperSDK’s own roadmap of being production-ready. If you want to get started with our testnet, check out the Nuklai Wallet repository, clone it locally, run it, and start interacting with the testnet. Nuklai testnet Nuklai testnet HyperSDK’s own roadmap HyperSDK’s own roadmap Nuklai Wallet Nuklai Wallet You can request test NAI tokens, create your own tokens, transfer native NAI and other user-created tokens, explore a basic version of the blockchain explorer, and even post something to Nuklai Feed - a simple social media platform. Additionally, the wallet lets you change the Nuklai RPC URL, allowing you to connect to your own Nuklai subnet running locally on your machine. You can watch the demo, and get started today! demo , demo If you prefer running your own Nuklai subnet locally instead of interacting with the official testnet, you can follow the directions outlined in our documentation . This allows you to do more, such as registering validator nodes for staking, delegating to validators, claiming staking rewards, and more. documentation documentation Welcome to the future where you can move a mountain with your fingers! Written by Kiran Pachhai, Lead Blockchain Architect at Nuklai

Nuklai Testnet Live: Dive Into HyperVMs, Build on a Scalable Blockchain, and Get Rewarded

নুক্লাই টেস্টনেট লাইভ: হাইপারভিএম-এ ডুব দিন, একটি স্কেলেবল ব্লকচেইন তৈরি করুন এবং পুরস্কৃত করুন

Nuklai Testnet Live: Tauchen Sie ein in HyperVMs, bauen Sie auf einer skalierbaren Blockchain und werden Sie belohnt

Nuklai Testnet Live: sumérgete en HyperVM, construye una cadena de bloques escalable y obtén recompensas

Nuklai Testnet Live : plongez dans les HyperVM, construisez sur une blockchain évolutive et soyez récompensé

नुक्लाई टेस्टनेट लाइव: हाइपरवीएम में गोता लगाएँ, स्केलेबल ब्लॉकचेन बनाएँ, और पुरस्कृत हों

Nuklai テストネット ライブ: HyperVM に飛び込み、スケーラブルなブロックチェーンを構築して報酬を獲得

Nuklai Testnet Live: HyperVM에 뛰어들어 확장 가능한 블록체인을 구축하고 보상을 받으세요

Nuklai Testnet Live: mergulhe nos HyperVMs, desenvolva um blockchain escalável e seja recompensado

Nuklai Testnet Live: погрузитесь в HyperVM, создайте масштабируемый блокчейн и получите вознаграждение

Nuklai Testnet Live: HyperVM'lere Dalın, Ölçeklenebilir Bir Blockchain Üzerine Geliştirin ve Ödül Alın

Nuklai Testnet Live: Đi sâu vào HyperVM, xây dựng trên Blockchain có thể mở rộng và nhận phần thưởng

Nuklai 测试网直播：深入探索 HyperVM，在可扩展的区块链上构建并获得奖励

As more users and applications flock to decentralized platforms, the need for efficient and robust blockchain infrastructure becomes increasingly apparent. Enter Polkadot's Join-Accumulate Machine (JAM), a groundbreaking solution more users and applications flock to decentralized platforms, the need for efficient and robust blockchain infrastructure becomes increasingly apparent. Enter Polkadot's Join-Accumulate Machine (JAM), a groundbreaking solution that promises to redefine the way we think about blockchain scalability and performance. What is JAM, and why is it a big deal? JAM is a new blockchain design that aims to address the limitations of existing systems by offering a more modular and minimalistic approach. It's not just another upgrade; it's a complete overhaul of the way blockchains operate. JAM's unique architecture enables it to achieve unprecedented levels of scalability and performance, making it a game-changer in the industry. To understand the significance of JAM, let's break down some of its key features: Distributed Availability: JAM targets a staggering 852 MB/s of distributed availability. In simpler terms, this means that JAM can process and store vast amounts of data at an incredibly fast rate. To put this into perspective, Ethereum, one of the most popular blockchain platforms, currently has a distributed availability of just 1.3 MB/s. JAM's capacity is over 650 times greater, enabling it to handle a much larger volume of transactions and data.


Computational Power: JAM boasts an impressive processing capacity of 500-5,000 EVM gas/µs and up to 4,000 reads/sec/core. This translates to an aggregated performance of up to 341 cores, surpassing the capabilities of a single native CPU core by a factor of 85. In layman's terms, JAM can execute complex computations and smart contracts at a much faster rate than existing blockchain platforms, making it suitable for a wide range of applications.


Smart Contract and ZK-Rollup Integration: JAM seamlessly integrates Smart Contracts and ZK-Rollups, two essential components of modern blockchain systems. Smart Contracts are self-executing contracts with the terms of the agreement directly written into code, while ZK-Rollups are a Layer 2 scaling solution that enables faster and cheaper transactions. By combining these technologies, JAM offers enhanced security and efficiency, making it easier for developers to build and deploy decentralized applications.


CoreTime Model: JAM introduces the CoreTime model, which democratizes access to the blockchain. This model allows developers to deploy services directly, optimizing costs and boosting economic efficiency. In essence, CoreTime makes it easier and more affordable for developers to build and run applications on the blockchain, leveling the playing field and encouraging innovation. JAM represents a paradigm shift in blockchain design, offering a more modular and minimalistic approach that facilitates seamless cross-chain communication and decentralized applications. Unlike traditional blockchain upgrades, JAM is a comprehensive overhaul that aims to address the limitations of existing systems and pave the way for unprecedented scalability and efficiency. Final Thoughts Polkadot's JAM represents a significant milestone in the evolution of blockchain technology. Its innovative design and impressive capabilities have the potential to reshape the landscape of scalability and performance, setting new standards for the industry. As developers and users navigate the rapidly changing world of blockchain, it's crucial to recognize the importance of adaptability and innovation. JAM embodies these principles, offering a more modular, minimalistic approach that facilitates seamless cross-chain communication and decentralized applications. The integration of Smart Contract and ZK-Rollups, coupled with the CoreTime model, democratizes access to the blockchain and opens up new opportunities for developers. By optimizing costs and boosting economic efficiency, JAM levels the playing field and encourages innovation across the ecosystem. The ultimate goal of achieving block times as close to 133 milliseconds as possible, while maximizing data propagation and minimizing latency, is an ambitious one. It will require a concerted effort from the entire blockchain community to push the boundaries of what's possible and unlock the full potential of this transformative technology. Don’t forget to like and share the story! Vested Interest Disclosure: This author is an independent contributor publishing via our business blogging program. HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR. As more users and applications flock to decentralized platforms, the need for efficient and robust blockchain infrastructure becomes increasingly apparent. Enter Polkadot 's Join-Accumulate Machine (JAM), a groundbreaking solution more users and applications flock to decentralized platforms, the need for efficient and robust blockchain infrastructure becomes increasingly apparent. Enter Polkadot's Join-Accumulate Machine (JAM), a groundbreaking solution that promises to redefine the way we think about blockchain scalability and performance. blockchain Polkadot What is JAM, and why is it a big deal? JAM is a new blockchain design that aims to address the limitations of existing systems by offering a more modular and minimalistic approach. It's not just another upgrade; it's a complete overhaul of the way blockchains operate. JAM's unique architecture enables it to achieve unprecedented levels of scalability and performance, making it a game-changer in the industry. To understand the significance of JAM, let's break down some of its key features: Distributed Availability: JAM targets a staggering 852 MB/s of distributed availability. In simpler terms, this means that JAM can process and store vast amounts of data at an incredibly fast rate. To put this into perspective, Ethereum, one of the most popular blockchain platforms, currently has a distributed availability of just 1.3 MB/s. JAM's capacity is over 650 times greater, enabling it to handle a much larger volume of transactions and data. Computational Power: JAM boasts an impressive processing capacity of 500-5,000 EVM gas/µs and up to 4,000 reads/sec/core. This translates to an aggregated performance of up to 341 cores, surpassing the capabilities of a single native CPU core by a factor of 85. In layman's terms, JAM can execute complex computations and smart contracts at a much faster rate than existing blockchain platforms, making it suitable for a wide range of applications. Smart Contract and ZK-Rollup Integration: JAM seamlessly integrates Smart Contracts and ZK-Rollups, two essential components of modern blockchain systems. Smart Contracts are self-executing contracts with the terms of the agreement directly written into code, while ZK-Rollups are a Layer 2 scaling solution that enables faster and cheaper transactions. By combining these technologies, JAM offers enhanced security and efficiency, making it easier for developers to build and deploy decentralized applications. CoreTime Model: JAM introduces the CoreTime model, which democratizes access to the blockchain. This model allows developers to deploy services directly, optimizing costs and boosting economic efficiency. In essence, CoreTime makes it easier and more affordable for developers to build and run applications on the blockchain, leveling the playing field and encouraging innovation. Distributed Availability: JAM targets a staggering 852 MB/s of distributed availability. In simpler terms, this means that JAM can process and store vast amounts of data at an incredibly fast rate. To put this into perspective, Ethereum, one of the most popular blockchain platforms, currently has a distributed availability of just 1.3 MB/s. JAM's capacity is over 650 times greater, enabling it to handle a much larger volume of transactions and data. Distributed Availability: JAM targets a staggering 852 MB/s of distributed availability. In simpler terms, this means that JAM can process and store vast amounts of data at an incredibly fast rate. To put this into perspective, Ethereum, one of the most popular blockchain platforms, currently has a distributed availability of just 1.3 MB/s. JAM's capacity is over 650 times greater, enabling it to handle a much larger volume of transactions and data. Distributed Availability: Computational Power: JAM boasts an impressive processing capacity of 500-5,000 EVM gas/µs and up to 4,000 reads/sec/core. This translates to an aggregated performance of up to 341 cores, surpassing the capabilities of a single native CPU core by a factor of 85. In layman's terms, JAM can execute complex computations and smart contracts at a much faster rate than existing blockchain platforms, making it suitable for a wide range of applications. Computational Power: JAM boasts an impressive processing capacity of 500-5,000 EVM gas/µs and up to 4,000 reads/sec/core. This translates to an aggregated performance of up to 341 cores, surpassing the capabilities of a single native CPU core by a factor of 85. In layman's terms, JAM can execute complex computations and smart contracts at a much faster rate than existing blockchain platforms, making it suitable for a wide range of applications. Computational Power: Smart Contract and ZK-Rollup Integration: JAM seamlessly integrates Smart Contracts and ZK-Rollups, two essential components of modern blockchain systems. Smart Contracts are self-executing contracts with the terms of the agreement directly written into code, while ZK-Rollups are a Layer 2 scaling solution that enables faster and cheaper transactions. By combining these technologies, JAM offers enhanced security and efficiency, making it easier for developers to build and deploy decentralized applications. Smart Contract and ZK-Rollup Integration: JAM seamlessly integrates Smart Contracts and ZK-Rollups, two essential components of modern blockchain systems. Smart Contracts are self-executing contracts with the terms of the agreement directly written into code, while ZK-Rollups are a Layer 2 scaling solution that enables faster and cheaper transactions. By combining these technologies, JAM offers enhanced security and efficiency, making it easier for developers to build and deploy decentralized applications. Smart Contract and ZK-Rollup Integration: CoreTime Model: JAM introduces the CoreTime model, which democratizes access to the blockchain. This model allows developers to deploy services directly, optimizing costs and boosting economic efficiency. In essence, CoreTime makes it easier and more affordable for developers to build and run applications on the blockchain, leveling the playing field and encouraging innovation. CoreTime Model: JAM introduces the CoreTime model, which democratizes access to the blockchain. This model allows developers to deploy services directly, optimizing costs and boosting economic efficiency. In essence, CoreTime makes it easier and more affordable for developers to build and run applications on the blockchain, leveling the playing field and encouraging innovation. CoreTime Model: JAM represents a paradigm shift in blockchain design, offering a more modular and minimalistic approach that facilitates seamless cross-chain communication and decentralized applications. Unlike traditional blockchain upgrades, JAM is a comprehensive overhaul that aims to address the limitations of existing systems and pave the way for unprecedented scalability and efficiency. Final Thoughts Polkadot's JAM represents a significant milestone in the evolution of blockchain technology. Its innovative design and impressive capabilities have the potential to reshape the landscape of scalability and performance, setting new standards for the industry. As developers and users navigate the rapidly changing world of blockchain, it's crucial to recognize the importance of adaptability and innovation. JAM embodies these principles, offering a more modular, minimalistic approach that facilitates seamless cross-chain communication and decentralized applications. The integration of Smart Contract and ZK-Rollups, coupled with the CoreTime model, democratizes access to the blockchain and opens up new opportunities for developers. By optimizing costs and boosting economic efficiency, JAM levels the playing field and encourages innovation across the ecosystem. The ultimate goal of achieving block times as close to 133 milliseconds as possible, while maximizing data propagation and minimizing latency, is an ambitious one. It will require a concerted effort from the entire blockchain community to push the boundaries of what's possible and unlock the full potential of this transformative technology. Don’t forget to like and share the story! Vested Interest Disclosure: This author is an independent contributor publishing via our business blogging program. HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR. Vested Interest Disclosure: This author is an independent contributor publishing via our business blogging program . HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR. Vested Interest Disclosure: business blogging program business blogging program

Why Polkadot's JAM is a Game-Changer for Blockchain Scalability

Beyond Sharding and Rollups: A New Approach to Blockchain Scalability

10 Questions with Founder and CEO Brian Vallelunga at Doppler via [The Startup Founder Interview Template]. 1. What is your company in 2–5 words? Scalable secrets management for developers. 2. Why is now the time for your company to exist? Developers are increasingly dependent on numerous services, each requiring authentication through API keys, database URLs, and other sensitive secrets. Secure management of these secrets is crucial, not only to safeguard a company's reputation but more importantly, to protect the personal data of potentially millions of users from breaches. As the complexity of digital services grows, the need for robust, streamlined solutions to secure and manage these secrets becomes more pressing. Our company exists to address this vital need, ensuring that security keeps pace with innovation and protecting all stakeholders involved. 3. What do you love about your team, and why are you the ones to solve this problem? It's often said, but in our case, it genuinely applies—our team is truly unique. What sets us apart is not just the expertise or the skill each member brings, but their extraordinary passion for our mission. This passion isn't just about the work; it's about making a meaningful impact. This shared commitment has fostered one of the most cohesive and vibrant cultures I've ever had the pleasure of being part of. It's this combination of passion, culture, and talent that uniquely positions us to tackle such challenging problems effectively. We aren't just working; we're driven by a collective mission to innovate and lead in our field, ensuring we provide the best solutions. 4. If you weren’t building your startup, what would you be doing? If I weren't dedicated to building our startup, I would likely be involved in another venture within the hard tech space, particularly one that leverages artificial intelligence to accelerate research and development. AI has the potential to vastly improve efficiency and innovation across various industries, and I'm deeply interested in exploring how these technologies can solve complex problems and drive progress. 5. At the moment, how do you measure success? What are your metrics? We operate our company based on a well-defined funnel, where each stage is guided by specific input and output KPIs, each assigned to a dedicated owner. Teams responsible for a shared stage in the funnel—both input and output KPIs—are required to hold weekly meetings to continuously refine and improve their performance metrics. At the top of the funnel, we focus on awareness KPIs, such as website visits, while at the bottom, we measure success through financial-based KPIs like the Annual Recurring Revenue (ARR) from self-serve and managed sales. To set our financial objectives, we begin with annual revenue targets established by the board and CEO, which our finance team then breaks down into quarterly goals. These are further divided into monthly KPIs by reversing through the pipeline: from revenue to awareness. These monthly KPIs are reviewed weekly in meetings with the leadership team and the KPI owners to ensure alignment and prompt action on emerging challenges and opportunities. 6. In a few sentences, what do you offer to whom? We provide a top-tier, developer-centric secrets management solution tailored for medium to large-scale companies. Our platform equips engineering teams with robust tools to store, manage, and orchestrate access to their secrets across various projects, teams, and environments, enhancing both security and operational efficiency. 7. What’s most exciting about your traction to date? The most thrilling aspect of our progress is our upward trajectory into larger markets. Our core mission is to secure the world's secrets, and it is particularly the larger enterprises that hold the highest density of sensitive information worth protecting. The recognition and adoption of our platform by these substantial institutions is not only a testament to the value we provide but also highlights the crucial need for our services in safeguarding their extensive digital assets. This shift is both validating and motivating as we continue to expand our reach and impact. 8. Where do you think your growth will be next year? While I am cautious about making speculative forecasts far in advance, if pressed for an estimate, I anticipate seeing our revenue grow by approximately 2 to 4x next year. 9. Tell us about your first paying customer and revenue expectations over the next year. Our very first paying customer was Tonebase! I had the opportunity to meet the founders through mutual friends and introduced them to our product with the Chipotle Sales Method. Their support was invaluable during our formative days—they provided consistent, high-quality feedback that was instrumental in shaping the foundational aspects of our product. Their early endorsement not only boosted our confidence but also set a strong precedent for the level of engagement we strive to maintain with all our customers. As for the upcoming year, we are optimistic about our revenue growth, aiming to build on this strong base and expand our reach further. 10. What’s your biggest threat? I love this question! As a security company, our most significant threat is undoubtedly the possibility of being hacked. We dedicate an immense amount of time, resources, and energy to ensure this does not happen, going above and beyond standard security practices. Despite these rigorous efforts, the risk remains—not just for us, but also for our customers. We believe in transparency and talk openly about the proactive steps we take to mitigate potential risks. Get Interviewed by HackerNoon via the Startup Founder Template 10 Questions with Founder and CEO Brian Vallelunga at Doppler via [ The Startup Founder Interview Template ]. Brian Vallelunga Doppler The Startup Founder Interview Template 1. What is your company in 2–5 words? Scalable secrets management for developers. 2. Why is now the time for your company to exist? Developers are increasingly dependent on numerous services, each requiring authentication through API keys, database URLs, and other sensitive secrets. Secure management of these secrets is crucial, not only to safeguard a company's reputation but more importantly, to protect the personal data of potentially millions of users from breaches. As the complexity of digital services grows, the need for robust, streamlined solutions to secure and manage these secrets becomes more pressing. Our company exists to address this vital need, ensuring that security keeps pace with innovation and protecting all stakeholders involved. 3. What do you love about your team, and why are you the ones to solve this problem? It's often said, but in our case, it genuinely applies—our team is truly unique. What sets us apart is not just the expertise or the skill each member brings, but their extraordinary passion for our mission. This passion isn't just about the work; it's about making a meaningful impact. This shared commitment has fostered one of the most cohesive and vibrant cultures I've ever had the pleasure of being part of. It's this combination of passion, culture, and talent that uniquely positions us to tackle such challenging problems effectively. We aren't just working; we're driven by a collective mission to innovate and lead in our field, ensuring we provide the best solutions. 4. If you weren’t building your startup, what would you be doing? If I weren't dedicated to building our startup, I would likely be involved in another venture within the hard tech space, particularly one that leverages artificial intelligence to accelerate research and development. AI has the potential to vastly improve efficiency and innovation across various industries, and I'm deeply interested in exploring how these technologies can solve complex problems and drive progress. 5. At the moment, how do you measure success? What are your metrics? We operate our company based on a well-defined funnel, where each stage is guided by specific input and output KPIs, each assigned to a dedicated owner. Teams responsible for a shared stage in the funnel—both input and output KPIs—are required to hold weekly meetings to continuously refine and improve their performance metrics. At the top of the funnel, we focus on awareness KPIs, such as website visits, while at the bottom, we measure success through financial-based KPIs like the Annual Recurring Revenue (ARR) from self-serve and managed sales. To set our financial objectives, we begin with annual revenue targets established by the board and CEO, which our finance team then breaks down into quarterly goals. These are further divided into monthly KPIs by reversing through the pipeline: from revenue to awareness. These monthly KPIs are reviewed weekly in meetings with the leadership team and the KPI owners to ensure alignment and prompt action on emerging challenges and opportunities. 6. In a few sentences, what do you offer to whom? We provide a top-tier, developer-centric secrets management solution tailored for medium to large-scale companies. Our platform equips engineering teams with robust tools to store, manage, and orchestrate access to their secrets across various projects, teams, and environments, enhancing both security and operational efficiency. 7. What’s most exciting about your traction to date? The most thrilling aspect of our progress is our upward trajectory into larger markets. Our core mission is to secure the world's secrets, and it is particularly the larger enterprises that hold the highest density of sensitive information worth protecting. The recognition and adoption of our platform by these substantial institutions is not only a testament to the value we provide but also highlights the crucial need for our services in safeguarding their extensive digital assets. This shift is both validating and motivating as we continue to expand our reach and impact. 8. Where do you think your growth will be next year? While I am cautious about making speculative forecasts far in advance, if pressed for an estimate, I anticipate seeing our revenue grow by approximately 2 to 4x next year. 9. Tell us about your first paying customer and revenue expectations over the next year. Our very first paying customer was Tonebase! I had the opportunity to meet the founders through mutual friends and introduced them to our product with the Chipotle Sales Method. Their support was invaluable during our formative days—they provided consistent, high-quality feedback that was instrumental in shaping the foundational aspects of our product. Their early endorsement not only boosted our confidence but also set a strong precedent for the level of engagement we strive to maintain with all our customers. As for the upcoming year, we are optimistic about our revenue growth, aiming to build on this strong base and expand our reach further. 10. What’s your biggest threat? I love this question! As a security company, our most significant threat is undoubtedly the possibility of being hacked. We dedicate an immense amount of time, resources, and energy to ensure this does not happen, going above and beyond standard security practices. Despite these rigorous efforts, the risk remains—not just for us, but also for our customers. We believe in transparency and talk openly about the proactive steps we take to mitigate potential risks. Get Interviewed by HackerNoon via the Startup Founder Template Get Interviewed by HackerNoon via the Startup Founder Template

Tech Founder Interview on Scalable Secrets Management for Developers and Scaling Yearly Revenue 2-4X

বিকাশকারীদের জন্য স্কেলেবল সিক্রেটস ম্যানেজমেন্ট এবং বার্ষিক আয় 2-4X স্কেল করার বিষয়ে টেক প্রতিষ্ঠাতা সাক্ষাৎকার

Interview mit Tech-Gründer zum Thema skalierbares Geheimnismanagement für Entwickler und Steigerung des Jahresumsatzes um das Zwei- bis Vierfache

Entrevista al fundador de tecnología sobre la gestión escalable de secretos para desarrolladores y el aumento de los ingresos anuales de 2 a 4 veces

Entretien avec le fondateur technique sur la gestion évolutive des secrets pour les développeurs et la multiplication par 2 à 4 des revenus annuels

डेवलपर्स के लिए स्केलेबल सीक्रेट्स मैनेजमेंट और वार्षिक राजस्व को 2-4X तक बढ़ाने पर टेक संस्थापक का साक्षात्कार

開発者向けのスケーラブルなシークレット管理と年間収益の 2 ～ 4 倍の拡大に関する技術創業者インタビュー

개발자를 위한 확장 가능한 비밀 관리 및 연간 수익 2~4배 확장에 대한 기술 창립자 인터뷰

Entrevista com o fundador da tecnologia sobre gerenciamento escalonável de segredos para desenvolvedores e aumento da receita anual de 2 a 4 vezes

Интервью с основателем технологии о масштабируемом управлении секретами для разработчиков и увеличении годового дохода в 2–4 раза

Geliştiriciler için Ölçeklenebilir Gizli Bilgi Yönetimi ve Yıllık Gelirin 2-4 Kat Arttırılması Konusunda Teknoloji Kurucusu Röportajı

Phỏng vấn người sáng lập công nghệ về quản lý bí mật có thể mở rộng dành cho nhà phát triển và mở rộng quy mô Doanh thu hàng năm gấp 2-4 lần

技术创始人访谈：面向开发人员的可扩展机密管理以及将年收入扩大 2-4 倍

Using MinIO and Python to Create Scalable and Efficient Event-driven Applications

স্কেলযোগ্য এবং দক্ষ ইভেন্ট-চালিত অ্যাপ্লিকেশন তৈরি করতে MinIO এবং Python ব্যবহার করে

Verwenden von MinIO und Python zum Erstellen skalierbarer und effizienter ereignisgesteuerter Anwendungen

Uso de MinIO y Python para crear aplicaciones basadas en eventos escalables y eficientes

Utiliser MinIO et Python pour créer des applications événementielles évolutives et efficaces

स्केलेबल और कुशल इवेंट-संचालित एप्लिकेशन बनाने के लिए मिनियो और पायथन का उपयोग करना

MinIO と Python を使用してスケーラブルで効率的なイベント駆動型アプリケーションを作成する

MinIO 및 Python을 사용하여 확장 가능하고 효율적인 이벤트 기반 애플리케이션 만들기

Usando MinIO e Python para criar aplicativos orientados a eventos escalonáveis e eficientes

Использование MinIO и Python для создания масштабируемых и эффективных приложений, управляемых событиями

Ölçeklenebilir ve Verimli Olay Odaklı Uygulamalar Oluşturmak için MinIO ve Python'u Kullanmak

Sử dụng MinIO và Python để tạo các ứng dụng hướng sự kiện có khả năng mở rộng và hiệu quả

使用 MinIO 和 Python 创建可扩展且高效的事件驱动应用程序

The TechBeat: Dencun Upgrade: Ethereum's Leap into the Future of L2 Scalability is Here (3/21/2024)

Stories, News & Mentions about SCALAC

Scalac’s Stories on HackerNoon