(Part 2) Best products from r/javahelp

To sharpen your OOP skills, I highly recommend these two books. I would go so far as to say they changed my life:

• Agile Principles, Patterns and Practices in C#
  
• Growing Object Oriented Software Guided by Tests
  
  For Java EE (don't ever say J2EE today! You'll look like you haven't been keeping up), I don't really have any book recommendations. I like the tutorial published by Oracle. I've generally found the Oracle documentation pretty good when for learning specific Java technologies.
  
  I would also recommend this book:
  
  
• Java Persistence with Hibernate.
  
  You'll learn a lot about how to properly use JPA by learning Hibernate, especially the pitfalls of using an ORM and how to avoid them. JPA is probably the hardest of all of the Java EE technologies to learn, I have found.

There are a lot of different strategies.

• UML/RUP (Rational Unified Process) Make lots of diagrams (UML) and lots of system requirements docs.
  
• TDD - Test driven development. Make Unit Tests first and then make code that passes the unit tests.
  
• CRC analysis - Napkin card type design that helps you figure out what classes you should have.
  
• Service based design - SOA type stuff. Define some high-level service APIs that different parts of your application communicate. Great when multiple team members are implementing different layers of your application.
  
  Basically you asking a methodology question and not a programming question. If you are asking questions like this you should probably start reading books like Code Complete: A Practical Handbook of Software Construction, Second Edition

Java is an excellent choice of language to learn if making an Android app is your eventual goal. While Kotlin is also available, your desire of wanting to learn a language in the context of physics simulation makes you a perfect audience for a highly recommended book called Computer Science: An Interdisciplinary Approach by Robert Sedgewick. This book is excellent because of the interesting problems and wide breadth of science and math topics that it touches upon while teaching the Java language.

The upside to going through this book is you will have an excellent foundation of Java and computer science, fully prepared to learn Android programming. The downside is that this will take longer than a tutorial approach, and the book costs money. Here is a sample chapter 2 in PDF format.

Please note that Robert Sedgewick has another book called Introduction to Programming in Java. The difference between this book and the Computer Science book is that the Computer Science book has the entire contents of the Intro Java book, but also has three additional chapters on computing theory, computing machines, and processor design. Since the two books cost about the same price, you might as well get the larger Computer Science book with additional content.

If you prefer video lectures or an online course, they are available for this textbook:

Video lectures

Coursera's Computer Science: Programming with a Purpose

Coursera's Computer Science: Algorithms, Theory, and Machines - This course covers the second half of the Computer Science book.

>Imagine you need high powered antennas, tons of bit shifting, very specific algorithms and so on. It’s a very complex topic.

That's not really the problem. The problem is more that you need access to the mobile phone network, so you either need to register as your own provider or you need some contract with an existing provider. After that, sending an SMS won't be that difficult, probably just need internet access to some gateway server.

Or you just pretend you're a normal client and use an android device (or even better a USB-Modem for a PC) and use that to send an SMS. That's probably the easiest solution but you need to make sure the software/driver has an interface that you can access easily with Java. Probably want to use a Linux PC and a compatible modem as that will be way easier.

From the command line there are two main options. The old way which includes Ant and newer ones like Gradle. Ant itself doesn't manage dependencies per se and can be coupled with Apache Ivy.

I recommend using Gradle. There will be a learning curve most definitely. Gradle is configured and manipulated with Groovy, so you have the full power of a scripting language. You can define tasks that will run consecutively.

This jumps right into the Gradle documentation, but describes some command line options:
http://www.gradle.org/docs/current/userguide/tutorial_gradle_command_line.html

A good discussion of the 3 main options:
http://technologyconversations.com/2014/06/18/build-tools/

I haven't read this book, but this is the best reviewed and recent book from this year on Gradle (I looked over the table of contents and it looks solid):
http://www.amazon.com/Gradle-Action-Benjamin-Muschko/dp/1617291307

Any reason you want to avoid a Java IDE?

I learned Python at CodeAcademy:
https://www.codecademy.com/learn/python

These books are generally good, but I cannot comment on quality of this one:
Head First - Python by Paul Barry
http://www.amazon.co.uk/Head-First-Python-Paul-Barry-y/dp/1449382673/ref=sr_1_1?ie=UTF8&qid=1451758567&sr=8-1&keywords=head+first+python

You better head to /r/LearnPython and /r/Python though :)

By "single-node linked list" do you mean singly-linked list? If so:

Each node in a singly linked list is just an object with an 'element' field to store stuff, and a 'next' (or 'pointer) field to store the next object in the list. If there is only one node, this node is the head and its 'next' field is set to null. If you want to add another node to the list, you just create a new node whose next field is null, and set the head's 'next' field to equal the new node. If you want to traverse the list you create a new node and set it to the head:

Node cursor = head;

then use a loop

while(cursor != null){
//do something with the element
cursor = cursor.next();
}

Once the cursor reaches the last item in the list, "cursor = cursor.next()" means that cursor is set to null and so the entry condition for the loop is no longer met and stops executing. So you are just continually setting the cursor to be the object pointed to in the 'next' field of each node until it is null.

The problem with a singly-linked list is that you can only traverse "forwards" travelling to each node's 'next' object until you reach the end. This is where a doubly-linked list comes in handy. A doubly linked list has a 'next' field and a 'previous' field. This makes it easier to delete nodes in the middle of the list as to delete one you can just set the 'next' field of the previous node to equal that of the current nodes 'next', and the 'previous' field of the next node to equal that of the previous node, then set the current node's previous and next fields to null, un-linking the node from the list. Once there are no references to an object in java, and the object makes no references to anything else, then Java's garbage collection will free up the space that object was taking up in memory, so the object is deleted.

In your example code, to see the difference between these two loops, you need to visualise in your head what is happening at each iteration, and the check that the while loop is carrying out for its condition. Since the second loop is checking the cursor's 'next' field to see if it is null, instead of checking to see if the cursor itself is null as in the first loop, this means that once the cursor is set to the last node (whose next is null) the loop will not execute again. So any actions you were carrying out on each element would not be carried out on the very last node because that node's 'next' is null, which doesn't meet the condition of the loop.

I found it helps a lot more if you can visualise what is happening with data structures, this book does a great job of explaining everything with illustrations of what is happening during traversals and deletions etc, if you can get your hands on it you should.

+1,

Maps, in particular, are usually not pretty when doing lambdas. Things like filtering, sorting or grouping results by are usually very concise.

Java 8 in Action does a rather good job in explaining how both streams and lambdas fit into Java 8.

Spring in Action is a pretty good book imo. New edition covers Spring 4.

I really like Intro to Java Programming, Comprehensive edition. link

It has tons of exercises and it covers lots of Java 8 features and JavaFx (the modern gui library for Java).

None of that is exactly decided on yet. We were testing with a 433Mhz rf transmitter and receiver like this.

We are logging the data as well, this is an additional project with the goal of getting live updates and displaying them.

I haven't read this but I wonder if something like the nutshell books would be what you are looking for.

https://www.amazon.co.uk/Java-Nutshell-Benjamin-J-Evans/dp/1449370829

As a separate but related thought to my earlier reply, here's a link to http://docs.oracle.com/javase/tutorial/ the Oracle Java Tutorials. These things (and the Sun version) were my holy book when I was learning Java. Unlike the more C style book you appear to be using they focus on drilling the object oriented design concepts into your brain right from the start.

I also recommend picking up http://www.amazon.com/Programming-Principles-Practice-Using-C/dp/0321543726

While it isn't Java per se, the concepts Stroustrop focuses on are relevant to programming in any language.

Check out Test Driven: TDD and Acceptance TDD for Java Developers
. Even if you don't fully buy into TDD, the concepts still apply.

If you have an understanding of how object oriented programming works, The Big Nerd Ranch guide to Android Programming is a great book. Not too expensive as far as CS textbooks go. If you aren't familiar with OOP or Java, though, you should start with basic programming in Java before moving on towards Android specific learning.

If it's for interviews, I highly recommend reading Cracking The Coding Interview.

The only thing you need to do is buy... and read a bool called "cracking the coding interview". Do the quiz questions... Cracking the Coding Interview, 6th Edition: 189 Programming Questions and Solutions https://www.amazon.co.uk/dp/0984782850/ref=cm_sw_r_cp_apa_i_5nTqDbS1RTATM

You do that... i guarantee youll blast through the interview.

https://www.amazon.com/Spring-Action-Covers-4/dp/161729120X

https://www.amazon.com/Growing-Object-Oriented-Software-Guided-Tests/dp/0321503627