Martin Odersky did a fantastic job with Scala then, and also with Scala 3 IMO from a language design perspective. When I first got into Scala, I was blown away by the language features and the type system. It was the reason I got back into the JVM and the reason for getting into functional programming (not pure FP).
Scala is a great language, and functional programming (not pure functional) made me a much better programmer. And functional error handling is a fantastic way to model success and failure, whether you’re using Either or the newer Result type.
I have to both agree and disagree with some of the commenters here regarding why scala declined in usage. There are several reasons.
1. People just got fed up with the push toward pure FP and the complexity. Pure FP and category theory, and effect libraries are just not for the average audience.
2. Android support for Kotlin drastically reduced the momentum as well
3. Spark usage was pretty heavy driver for using Scala and I’m not sure about it’s used as much.
4. Scala became more and more niche as a result of item 1 above.
This being said, I switched to Kotlin for all server side work. I think a language and in particular the ecosystem, needs the vision/stewardship that can offer more practicality and balance in the language design, programming style, tooling, and frameworks. Kotlin just became a simpler language with better support for all of the above.
I can’t think of a better company to drive the development than Jetbrains. I don’t agree with all the choices, but Kotlin overall is a beautiful, simpler language, with all the practicality, and support needed to keep it going.
However, now that Java is making strides in the language features, as compared to historical improvements at the VM level, I’m curious to see how the market share for Kotlin outside of android is going to be affected.
Personally, I still prefer Kotlin for the practical FP support, Ktor as an HTTP server, and pretty good compatibility with Java. And lastly, I think there is enormous potential in multiplatform, as a strong alternative to typescript/react native for mobile.
Disclosure: I am biased as I’m developing some libraries and soon to be made (more) public server framework.
Also agree with some of the comments here that majority of articles about OAuth are incredibly verbose, but really hard to actually implement without concrete examples.
I personally think having Curl requests as part of the examples would solve this problem.
Nice idea and the site looks well done! Congrats on launching this. I played around the site a bit and with the different panels.. a few thoughts/questions...
THOUGHTS
1. Target: Is the market for enterprise/work or for consumer/personal use or does it not matter? Similar question for people, is it more for people who need diagrams in combination with notes and if so, are these mostly technical people who could author both the notes / diagrams and for non-technical people who would read/consume them?
2. All-In-One: The inevitable question/concern on a tool that combines many things into one, is that, it being good but not great at any one thing. This is something I'm also dealing with on one my projects. How do you address this concern?
3. Limitations: Are there any limitations with the note taking, or the diagramming capabilities compared to specialized products / apps like Joplin, UpNote, Bear, or Draw.io ?
QUESTIONS
1. Tab: Is a "tab" analogous to a "note" in other apps?
2. Panels: Are all the panels linked to a tab and is there a limit to the panels?
3. Folders: I didn't quite get it, but how are multiple notes organized into 1 collection?
4. Diagrams: Do you have an example of a sophisticated diagram made with your app?
I use diagramming quite often, but it's mostly for work purposes for technical software architecture diagrams, which I eventually embed into other wiki pages and/or git readmes. For personal use at home, I can't remember the last time I had to diagram anything. The first thing that comes to mind is how does the diagramming compare to something more specialized like draw.io. I can definitely see potential in this for work purposes.
Nice work on this! I’ve looked into task queue libraries for Node and Java in the past. Yours looks straight-forward. A few questions:
1. What’s the error handling strategy for when a task/payload fails?
2. How exactly do delayed tasks work? For example, are you delaying execution until say 10mins later? How do you process delayed tasks in sequential timed order?
3. What kind of metrics/stats are available?
4. Is there a way pause and resume or is this the same as start and stop?
Some suggestions based on my own experience working on various projects/services/startups over the years…
1. “Avoid 100%”: By this I mean avoid 100% in that balance can be as little as reserving a minimum of 1% to X% of your available time on things unrelated to the startup (self care, family and friends, health and exercise, leisure, etc). I’ve met enough people that go a full 100% and let life pass them by.
2. Time off: Take a weekend, a week, what ever X time you need
3. Self-Care day: Dedicate a day or evening for yourself. I usually use Wednesdays and refer to them as no work Wednesdays. I focus on myself, spending time with people, errands, leisure, etc
4. Focus on other things. Funny enough I was surprised how much inspiration and ideas I got from doing things completely unrelated to my project/startup
5. Change: This is subtle but quite useful, make a change in your core responsibilities to a lateral role. As founders, we are typically generalists and do a lot of different things in the early stages. Sometimes you can become overwhelmed, stressed, just grinding work. If you can, change what you’re doing. Say instead of intense engineering, spend some time or stretch of time focusing on product, connecting with customers, ideation. Just anything other than the previous role.
6. Time and Place: I’ve always been a night person so my best work is at night, but I realized the type of work I do best at night is more creative, research oriented, ideation type work. It’s not hard problem solving, it’s more relaxed, care free, inquisitive, creative work. Understand when and in what setting you perform the best type of work.
I think the main differences Scala being much more of a functional programming language where as Kotlin is a bit of a balance between Java/OOP and FP and affects the complexity/learning curve of the respective languages.
OVERVIEW
- Scala is much more of a functional programming language
- Scala has a steeper learning curve
- Scala community/ecosystem leans much more towards FP
- Kotlin is like Functional Programming "lite"
LANGUAGE
- Scala: has higher kinded types
- Scala: has for comprehensions
- Scala: has type classes
- Scala: has built in support for monads
- Scala: has better support for encoding errors at compile time
MARKET
- Kotlin: has heavy usage on Android
- Kotlin: on the server side is pretty active too
- Kotlin: integrates nicely with java
- Kotlin: multi-platform support
This is some impressive stuff! Congrats on a sizable achievement. I just went through your website, have a few questions...
Questions:
1. SCALA: is the generated code ONLY scala? are other languages supported?
2. CODE-GEN: is it designed only for code generation for a target http framework or does it actually provide an "API Server" itself ( e.g. like graphQL )
3. COMPARISON: the list of frustrations with other solutions, listed in your intro/technology goals are somewhat high-level. what are the "leaky abstractions" or "non-deterministic behaviour"?
4. SETUP: does someone need to know scala to use this ? ( depends on #1 above )
5. DSL : is the protoforce code implemented as a DSL in Scala or its a "language" in itself?
6. IDE : how do you check/compile the code? does it integrated with an IDE?
As a Scala Engineer myself ( though I mostly work in Kotlin now for Android/Server ), this looks great, but most Scala engineers i've met are focused on Spark, and using Play Framework/Http4S, etc. How big is the actual market for Scala API tools?
I’m working on a Kotlin Framework to build Apps, APIs, CLIs, Jobs and Mobile apps, it’s available at https://github.com/slatekit/slatekit with docs at https://www.slatekit.com Been at it for a several years on and off, I’m not sure what’s going to happen to it, but I am using it to build a mobile app and self hosted mobile backend.
I think it’s pretty simple why you’d want to use Kotlin on the server; full stack Kotlin development: 1 language for both Android and Server(lowers time, costs, and you can share code).
And Kotlin multi-platform is making good progress, so potentially you can also build shared code for iOS and JavaScript. Again, it all comes down to time, cost, simplicity.
Lastly, I have to say, after using futures in Java/Scala, async/await in JS, Kotlin got it right with coroutines, channels and flows. I’m not exactly sure what the roadmap for concurrency looks like in the Java world(even with project loom, etc). While Java is moving fast(finally), I think it’s still weighed down by legacy stuff (nulls, mutable code, lack of expressions and more)
Agree completely with everything you said and your observations regarding job market. I’ve been doing Scala for several years and I also would not recommend it to anyone unless they have a deep desire to do pure FP(functional programming) on the JVM. The ecosystem/libraries are unnecessarily complex IMHO.
If you want FP-Lite, I recommend Kotlin, it’s very pragmatic, reasonably functional, and mid way between Java and Scala. I actually converted all my personal projects from Scala to Kotlin, including my framework https://github.com/slatekit/slatekit which took about a 4-6 weeks from the original code base.
What’s your stance on Dual licensing? I honestly have had mixed Opinions on this, but I finally settled on Dual licensing and/or BSL 1.1 as a nice compromise. I think open source developers create a lot of value, and should have the facility to be compensated and have their passion become their job. Plus this whole Re-Licensing trend toward SSPL/BSL/Dual is IMHO the natural evolution of open-source strategies.
I’m working on a Kotlin Framework, more like a collection of small, modular libraries that can be used for both server side and android. https://www.slatekit.com
My goal is a simpler, lighter, modern version of Spring framework (for Java) , but for Kotlin for both server and android. Also, looking into making it cloud provider agnostic.
I’m not too familiar with ruby but I’m curious why they didn’t just add optional types after the variable names. Such as in Kotlin, Scala, Swift like “var x:Int”? I thought this is how Python was adding types to its language. I could see this though fundamentally changing the philosophy/design of the language but I think dynamic languages are heading toward type safety anyway.
The Scala language is great but the ecosystem sacrifices simplicity for pure FP. Scala has always suffered from complexity problems due to libraries. For example, using Http/JSON/Database libraries have always been a lot harder than they need to be due to a die hard approach to pure FP.
Scala 3 looks pretty good, but I just can NOT see myself using Scala again, after having worked with it for 4-5 years at work and on personal projects. I write mostly/reasonably FP code without using Cats/Category theory. I’ve recently moved all my code from Scala to Kotlin and I’m loving it, found the perfect balance with Kotlin.
Focus on no-code, low-code approaches and tools to building a product to validate a problem and your solution to it.
For example, use a “no code” approach first and simply use tools to design or build a simple Product, from concept to creation. Use cloud services like Invision to create a prototype, website builders/template to validate need/interest in an idea. These are all things that anyone can pick up reasonably well without coding.
Essentially, what I’m saying is focus on non-technical skills related to ideation, proof of concept, product validation, etc.
Accounts (I believe ) are similar to email addresses. So it's like having an account [email protected] and trying to migrate that to [email protected]. Essentially the account is tied to the domain/server.
Modular Monoliths would be a healthy middle-ground between monoliths and micro-services.
My comment on the same topic of modular monoliths is here: https://news.ycombinator.com/item?id=21853902
Like many things in life, there are no absolutes. So rather than going to opposite ends of the spectrum, check out modular monoliths.
This approach is a nice balance (IMHO), since you start off with monolith but it is broken down into cleanly separated modules. Each module can potentially become its own micro-service if or when the time comes.
In terms of implementation, this can be easily done, for example we do it JVM/Kotlin where each microservice is its own project that produces a binary/jar. All the projects are part of a multi-project build. Lastly we have a common project for shared code, utils, types, enums, interfaces, etc and an application project that loads/sets up all the microservices from each project. Works great so far. And when you do have break up 1 project into its own service, the effort is fairly manageable.