When comparing Java vs Laravel, the Slant community recommends Java for most people. In the question“What are the languages that have most powerful and easy to use free IDEs?” Java is ranked 4th while Laravel is ranked 8th. The most important reason people chose Java is:
Because Java is statically typed, integrated development environments (IDEs) for Java can provide a lot more feedback on errors you will encounter. Java IDEs can give you specific errors in the location where they occur without having to run the code every time. This makes is faster to debug and learn from your mistakes. IDEs also have extensive auto complete capabilities that can help you learn the programming libraries you are using faster and tell you what functions are available.
Ranked in these QuestionsQuestion Ranking
Pro Fantastic IDEs
Because Java is statically typed, integrated development environments (IDEs) for Java can provide a lot more feedback on errors you will encounter. Java IDEs can give you specific errors in the location where they occur without having to run the code every time. This makes is faster to debug and learn from your mistakes.
IDEs also have extensive auto complete capabilities that can help you learn the programming libraries you are using faster and tell you what functions are available.
Pro Most commonly used language in industry
Pro Consistent programming standards
Most Java code follows very standardized coding styles. This means that when you're starting out, there are fewer questions about how you should implement something as the programming styles and patterns are well established and consistent. This consistent style means that it's often easier to follow others' example code, and that it's more likely to meet at least a certain minimum standard of quality. This discipline with consistent stylistic standards also becomes useful later, when collaborating on projects with larger teams.
Pro Best introduction to "C style" languages
The Java syntax is very similar to other C style languages. Learning the fundamentals of Java will port over well to other languages so you can apply what you've leaned to other languages afterwards.
Pro Introduces you to object oriented languages
Object Oriented Programming (OOP) is a paradigm that teaches you to split your problem into simpler modules with few connections between them; it's the most common paradigm used in industry. Java is the best choice as an introduction to object oriented languages because, as a statically-typed OOP-only language, it very clearly highlights core OOP principles such as encapsulation, access control, data abstraction, and inheritance.
While a scripting language provides more flexibility and terseness, learning a scripting language first would not instill these fundamental concepts as well, as they tend to obscure details such as how types work, and are less encouraging of an object oriented style.
Pro Platform Independent
Because of the Java Virtual Machine, the Java programming language is supported wherever a JVM is installed.
Pro Massive amount of libraries and APIs
Java has been around for such a long time that there have been tens of thousands of APIs and libraries written for almost anything you want to do.
Pro Comes with its own CLI
Laravel comes out of the box with it's own CLI called Artisan. With Artisan developers can do several different tasks such as migrating databases, seeding databases, clearing the cache and much much more.
Pro Good documentation
Laravel's documentation is thorough and very good. It covers everything and is very helpful to experienced and new users alike.
Pro Comes with an excellent built-in ORM
Laravel's Eloquent ORM is a simple and fast Object-Relational Mapping which helps with organizing the application's database. It supports the most popular databases (MySQL, Postgres, SQLite, etc.) out of the box.
Pro Good for building RESTful APIs
With migrations, powerful and intuitive Eloquent CRUD, resource routing, and simple JSON response out of the box, a complete REST API can be written in hours.
Pro Easy to write web apps with authentication
Laravel comes with Authentication capabilities and a fully-powered Auth class out of the box. For passwords it uses bcrypt.
Pro Gives developers a great degree of freedom in how they set up their project structure
Laravel allows for free configuration and does not force developers to use a single project structure, instead they can change it to how they wish.
Pro Handles event queuing
Laravel supports event queuing and it does so in a very simple way. To create an event that should be queued just run:
php artisan handler:event SendPurchaseConfirmation --event=PodcastWasPurchased --queued
This creates a handler that implements the
Illuminate\Contracts\Queue\ShouldBeQueued interface. Now when this handler is called it will automatically be queued by the event dispatcher.
Pro Gulp tasks in the form of Laravel Elixir
In Laravel 5.0 they added Laravel Elixir, which provides an API for using Gulp tasks for Laravel applications. Elixir supports several CSS preprocessors and even some test tools. But it's still in the early stages of development and it will be developed even further in the following releases. With more methods and more Gulp tasks supported.
Pro Can use Symfony components
Laravel uses many libraries built for the Symfony PHP framework. Many of these libraries are well-built and have been tested by users before. Since the point of using a web framework is to shorten development time and to avoid reinventing the wheel for problems that have already been solved, then it's logical for a framework to use libraries already built to solve problems that have already been solved.
Pro Extremely powerful template system
Laravel has a powerful template system called Blade. It's quite similar to Twig or Moustache with lots of curly braces but the real power comes from the usage of PHP code directly in the view. Blade templates compile directly to raw PHP and are processed in the server when a request is made.
Con Worst-of-both-worlds static type system
It's just barely good enough to make decent IDEs, but it's not at the level of Idris or even Haskell. For large enterprise projects, the IDE support is important, but the static typing in Java just gets in the way for the smaller projects beginners would start with.
Python is duck typed and this makes small programs easy to develop quickly, but the price is that you have to write unit tests to avoid breaking larger programs. In contrast, you can be reasonably certain that a program that actually compiles in Idris does what you want, because assertions are built into the powerful type system. Java can't make that claim and still requires unit tests. Java has the worst of both worlds because of its poor static type system.
Con Lacks modern features
Java evolves very slowly - lambda expressions weren't available until Java 8 (which is not available on Android), and despite getters/setters being a long-time convention, the language still doesn't have native accessor syntax (a la C#'s properties). It's unlikely newer, popular features like list comprehensions or disjoint union types will be available anytime soon. While not strictly required for novice programmers, these make problems more complicated and tedious than they need to be - for example, when a simple local function would do, (portable) Java demands anonymous inner classes, an interface and a class, or worse, no abstraction at all.
Con Confusing mis-features
Some features in Java can be quite confusing for beginners.
Encapsulation is needlessly obfuscated with a confusing access control model. As an example, the "protected" keyword not only grants access to child classes, but to the entire package. Since small programs are written as one package, it becomes functionally equivalent to "public".
In OOP, everything is supposed to be an object, but, in Java, primitive types such as integers, booleans and characters are not, and must be handled as special cases.
Java continues to lack many high-level features, and, particularly prior to Java 7, compensated by adding confusing Java-only features, such as anonymous subclasses. Some example code is unreadable without knowing a special-case feature, libraries differ in style based on when they were released or what platform they target(e.g., Android vs. Desktop), and some solutions just aren't available on some platforms.
Con Too verbose
- A Hello world needs package, class, static method and the actual
- Reading a line from input requires instatiating 5 objects in the right order.
- Exceptions are everywhere, particularly since all values are nullable.
- Java has a getter/setter culture, but without native syntax support.
- portable Java code lacks anonymous functions, and continues to lack good support for partial application, compensating instead with verbose design patterns, kludges like anonymous inner classes, or just inline code.
- It is statically typed without type inference, with a culture that promotes long class names.
- Poor support for sum-types and pattern matching leads to overuse of inheritance for dynamic dispatch and chains of nested conditionals
Especially for beginners, this can make reading Java code feel overwhelming; most Java courses tell students to simply copy, paste, and ignore a significant percentage of the code until they've learned enough to understand what it means.
For experienced programmers, this makes Java feel tedious, especially without an IDE, and actively discourages some solutions and some forms of abstraction.
Con Locks you into the static OOP mindset
Con Half-baked generics
Type erasure means it doesn't even exist at runtime. The whole generics system is confusing for beginners.
Con Garbage collection may teach bad habits
Java is a garbage collected language and it does not force programmers to think about memory allocation and management for their programs. This is fine most of the time. However, it may cause some difficulties in adjusting to a non-GC language (such as C for example), where memory management needs to be done manually. But if good coding practices and habits are followed, this shouldn't be much of a problem.
Con Enforces some misguided principles
Java utilizes principles that organize code into "classes" as the central concept, instead of more familiar organizational methods.
Con Long learning curve
Con Static typing but no type inference
The type system gets in your way more than it helps. Heavy IDE support is absolutely required for reasonable productivity. This means beginners have to learn not just the language, but eventually a complex, heavyweight IDE too.
Con Checked exceptions
Catch blocks can be a frequent source of mistakes.
While the speed doesn't seem to be an issue with it (on local tests), in production it may be hindered. The framework creates a ton of files and folders, some of which your app might not even use. Not good if you don't like having a ton of folders and rigid non-standard PHP folder structure for development.
Con Not really suited for enterprise development
Laravel is great for putting a blog together quickly, but it does not really pack all the features for a full enterprise grade website.
Con Steep learning curve
While a lot of times you can write things in plain PHP, it will hinder you down the line when you want to use core features and find that you have to rewrite code which then causes issues throughout the app. Documentation is good, but you need to know what you are looking for and practical examples are non-existent. Many features have been updated throughout the versions in such a short time that tutorials you find online are confusing to sort through outdated tutorials and guides that no longer work or have been depreciated.