Iodine is a full superset of regular Java, but provides enhanced abilities that will make writing Java code easier and more productive. All your existing Java code should compile right away (just copy it over), and you can start making use of the enhancements, right away.
For the initial release, these include:
optional type inference with the var keyword
"out" and "by-reference" parameters
type extensions
partial classes
powerful aspects
accessing getters/setters using property syntax
global (class-less) methods and fields
Cocoa-style multi-part method names (aka named parameters)
and the list will continue expanding, with support for structs/records and easy property definitions, for example, coming in version 9.3. Read about all the language extensions here.
Iodine also does away with some silly limitations that plague Java developers, such as being limited to having one class per file (or, indeed, one file per class) or having to match the package/namespace structure of your code with folders on disk.
Great, but why is it not totally free? It says on the page Try Iodine for free. When you click further, it is a 30-day free trial of some sort, and you need your email to download:
The opposite, it seems. They got rid of the good parts (the JVM and the industry's best IDE ecosystem), kept the bad (the Java language), added their own lockin-flavoured herbs and spices, and now they have the gall to charge $800/seat for the mess. What a joke.
"The opposite, it seems. They got rid of the good parts (the JVM and the industry's best IDE ecosystem), kept the bad (the Java language), added their own lockin-flavoured herbs and spices"
You can even use it for Android and IOS development if you use Flutter which is basically Java swing meets ReactJS but written in Dart which is what Java syntax would look like if it was created today.
I love Eclipse and am unable to cope with the laggy, crashing trainwreck that is Android Studio. The fucking joke is: it runs the build as another process, yet still manages to be completely unresponsive and prone to crashing.
Every developer with Android experience knows that, and both require more resources than either Netbeans or Eclipse, but whatever Google makes to their fork of Intellij, makes Android Studio even worse.
The android dev tools have never been that great, and I feel they’re even worse with the new Gradle build system (although yay, Maven dependcies without needing to pull in Ivy?)
I use IntelliJ daily without issues, literally the only difference between my work and that of a Android Studio user is the Android plugin and the different build system.
Yea I use Intellij Ultimate for just about everything.
And at least on my computer (I know this isn't representative) Android Studio isn't the laggy piece of crap everyone says it is. It works just like Intellij but with Android support.
Yes, android studio is clunky. But give good experience. Autocomplete variable name and lot refactoring technique. Actually it similiar to vs + resharper. The different is you cannot remove unplug reshaper from android studio
I love Eclipse for working in Java, and I love IntelliJ for working in Kotlin.
My impression is that people who don't like IDEs haven't put the effort into figuring out how to use them effectively -- modern IDEs have incredible power to increase productivity, but you have to learn how, and you have to make some accommodations in how you work.
I say this from experience: I started my career coding C/C++ in Emacs and I didn't get the fuss with IDEs. Then 10 years ago I started working in Java in Eclipse and I realized what I had been missing. But in order to realize the full benefit of the IDE I had to adjust to how the IDE wants to work, e.g. spend time configuring the automatic code formatter, and let go of some of my formatting quirks that the automatic formatter couldn't handle.
Eclipse for Java is ok, but Eclipse needs and lackluster made me write many emacs lisp extension (and not because of eclipse ergonomics, for handling build time parameters), that says something.
My general experience is that Java needs an IDE because the language forces a bunch of boilerplate and a file/directory structure that is very difficult to navigate without a bunch of tooling. However, in other languages, the gap between the IDE experience and the well-configured vim/emacs experience is much narrower.
I programmed Java for 15 years in mostly eclipse. The past 3 years I've been doing go in vim. Just recently I switched to Gogland for go, which is a full blown IDE. It's been life-changingly good. I forgot just how nice it is to have proper tools that just work. So even in a "simple" language like go, an IDE can make a huge difference if you care to learn it.
I've had mostly the opposite experience: I've used vim and emacs/evil-mode for 10 years or so now and now, since my day-job involves lots of pair programming, I've had to use tooling that other people are comfortable with (e.g. Atom/VSCode/Intellij) and, the only places I find a clear win over my old tools are places where I rely on Intellij's features (auto-implementation of interfaces and other boilerplaty issues with Java). When I've worked in Javascript/PHP/etc., I've never found the overhead of an IDE to be worth it.
Also, I haven't written much go, but my general impression is that the language trends on the verbose side because of the lack of things like generics and it's error-handling strategy, so I'm not too surprised that it's more pleasant to use an IDE for go than it is to produce it manually.
Also, most of my side-projects are in Common Lisp and, I've yet to find a "mainstream" programming environment that's more pleasant to work with than my SLIME/emacs setup for writing CL.
Unless I misunderstood you, this does not sound like the opposite experience, but the same experience. You say that (for Java) you found the IDE, IntelliJ, better than the editors vim, Emacs, Atom, VSCode.
No I was saying that I found that certain kinds of languages (verbose, boilerplate-y languages like Java) benefit from an IDE to automate the boilerplate away while more concise languages (like Common Lisp or Haskell) benefit very little from having an actual IDE vs. a simple text editor.
Only because IDEs in other languages are weak as hell. It is not directory structure/boilerplate. It is code completion, analysis, discovery and all other similar goodies. It is just so much slower to produce the same functionality as you are used to.
Even basic things - ability to see all callers, all available methods, warnings on bad constructs and yeah, templates for often needed sysouts ...
Refactoring. Oh just a simple thing, like simplest of all available refactorings, rename something with zero worries about forgetting some place or changing one more ... I missed this ability so much ...
I can generally use macros in vim + vim integrations for things like ag or rg to do refactorings fairly easily: sure, it's not as automatic as Intellij, but it's not bad either.
Also, depending on the language, the tooling in Emacs can get all the other IDE features you are talking about: for haskell there's ghc-mod + intero, for common lisp there's slime, etc. if you install the appropriate plugins and then use something like Syntastic/Flycheck, you can have all the nice editing abilities of vim/emacs as well as most of the useful parts of an IDE's language support.
These IDE's often work okay from a user perspective. It's different when you are writing a plugin and read the source code. Then you see how the sausage is made, and it's not pretty.
Kotlin is cool but it's not C#. The project that's most "C# for the JVM" is called Stab and it's widely rumored that it was (as its an anonymous project) a precursor to Kotlin on the side.
Projects by no-name companies too insecure to open-source their stack but also too shameless not to flog it every chance they get are not worth even considering. Programming languages that aren't fully and permissively open aren't worth a bucket of spit. And I don't provide my business to the latter, either.
Especially when superior options exist, because "C# on the JVM" also isn't even particularly valuable when you're a competent programmer who is capable of learning new things.
So, a JVM language that’s not much more than just a C# clone, but with no IDE or compiler support for Linux?
This sounds like it’s not going to be successful soon. In the long term, if you want to compete with Java, you’ll need good integration with existing IDEs, and with existing JVM languages.
Yes, but kotlin can already translate Java to Kotlin, and provides 90% of this – with far better IDE and editing support. Forking Kotlin seems like an easier solution.
Especially because of the IDE and compiler support for this, which means it can only reasonably be developed on Windows, and then you might as well use C#.
Groovy is also almost a superset of java. They removed a few syntactical contstructs which make it incompatible but most of them are trivial to tranform to groovy.
> almost a superset of java. They removed a few syntactical contstructs
Unfortunately "almost" doesn't cut it with programming languages. And they changed, not "removed", syntax. Because Apache Groovy has those (many, not "few") incompatibilities with Java (e.g. meaning of == , public visibility as default, closures instead of lambdas, etc), it might as well be a different language.
I don't get it: there is already a widely accepted 'better' Java called Kotlin, that features much more than this: way better integration with IDEs, way better integration with existing Java codebases, better everything... Yet somehow we should start using NEW IDE with NEW language supported by completely unknown company with zero guarantees about its support. I just don't get it.
It is usually fun exercise that has little certainty (you know what to do and even how if you bother to study) in it, but is still intellectually satisfying. Usually great learning experience. Once in a while, project that wins over others (requires a lot of bullshitting on conferences tho).
While we're on the subject of interesting titbits, Apache Groovy was first announced 14 years ago. It's creator, James Strachan, announced Groovy on 29 August 2003, hosting it at groovy.codehaus.org.
68 comments
[ 3.0 ms ] story [ 121 ms ] threadFor the initial release, these include:
optional type inference with the var keyword "out" and "by-reference" parameters type extensions partial classes powerful aspects accessing getters/setters using property syntax global (class-less) methods and fields Cocoa-style multi-part method names (aka named parameters) and the list will continue expanding, with support for structs/records and easy property definitions, for example, coming in version 9.3. Read about all the language extensions here.
Iodine also does away with some silly limitations that plague Java developers, such as being limited to having one class per file (or, indeed, one file per class) or having to match the package/namespace structure of your code with folders on disk.
http://www.elementscompiler.com/elements/iodine/
because rent and food isn't, either.
no, that's just entirely false.
Good luck with that.
Fire. http://www.elementscompiler.com/elements/fire/
Water. http://www.elementscompiler.com/elements/water/
Uh... I don't agree for IntelliJ/Android Studio, and I'm sure some people love to work with NetBeans and Eclipse.
I use IntelliJ daily without issues, literally the only difference between my work and that of a Android Studio user is the Android plugin and the different build system.
And at least on my computer (I know this isn't representative) Android Studio isn't the laggy piece of crap everyone says it is. It works just like Intellij but with Android support.
My impression is that people who don't like IDEs haven't put the effort into figuring out how to use them effectively -- modern IDEs have incredible power to increase productivity, but you have to learn how, and you have to make some accommodations in how you work.
I say this from experience: I started my career coding C/C++ in Emacs and I didn't get the fuss with IDEs. Then 10 years ago I started working in Java in Eclipse and I realized what I had been missing. But in order to realize the full benefit of the IDE I had to adjust to how the IDE wants to work, e.g. spend time configuring the automatic code formatter, and let go of some of my formatting quirks that the automatic formatter couldn't handle.
Also, I haven't written much go, but my general impression is that the language trends on the verbose side because of the lack of things like generics and it's error-handling strategy, so I'm not too surprised that it's more pleasant to use an IDE for go than it is to produce it manually.
Also, most of my side-projects are in Common Lisp and, I've yet to find a "mainstream" programming environment that's more pleasant to work with than my SLIME/emacs setup for writing CL.
Even basic things - ability to see all callers, all available methods, warnings on bad constructs and yeah, templates for often needed sysouts ...
Refactoring. Oh just a simple thing, like simplest of all available refactorings, rename something with zero worries about forgetting some place or changing one more ... I missed this ability so much ...
Also, depending on the language, the tooling in Emacs can get all the other IDE features you are talking about: for haskell there's ghc-mod + intero, for common lisp there's slime, etc. if you install the appropriate plugins and then use something like Syntastic/Flycheck, you can have all the nice editing abilities of vim/emacs as well as most of the useful parts of an IDE's language support.
Especially when superior options exist, because "C# on the JVM" also isn't even particularly valuable when you're a competent programmer who is capable of learning new things.
Kotlin does not support value types, unsafe low level coding, and it is going to be a while until it can match .NET Native.
This sounds like it’s not going to be successful soon. In the long term, if you want to compete with Java, you’ll need good integration with existing IDEs, and with existing JVM languages.
Especially because of the IDE and compiler support for this, which means it can only reasonably be developed on Windows, and then you might as well use C#.
Unfortunately "almost" doesn't cut it with programming languages. And they changed, not "removed", syntax. Because Apache Groovy has those (many, not "few") incompatibilities with Java (e.g. meaning of == , public visibility as default, closures instead of lambdas, etc), it might as well be a different language.
Furthermore iodine is already the name of a popular IP-over-DNS tool.
To use a JavaScript analogy, Kotlin is CoffeScript, and Iodine is Typescript.
Codegear had a partnership with them.
They were also the only company to offer a Swift compiler, before Apple released it as open source.
Here is my guess at an answer.
Iodine: our Java implementation should include features from newer languages
[0] http://paulgraham.com/fix.html
I would definitely call this a regression, not an enhancement