Best systems analysis & design books according to redditors
We found 868 Reddit comments discussing the best systems analysis & design books. We ranked the 150 resulting products by number of redditors who mentioned them. Here are the top 20.
We found 868 Reddit comments discussing the best systems analysis & design books. We ranked the 150 resulting products by number of redditors who mentioned them. Here are the top 20.
Here's my list of the classics:
General Computing
Computer Science
Software Development
Case Studies
Employment
Language-Specific
C
Python
C#
C++
Java
Linux Shell Scripts
Web Development
Ruby and Rails
Assembly
Android team lead here, I've been working with Android commercially since 2009 (before Android 2.0 was released) and have worked at, or done work for, some big companies (Mozilla, Intel, Google, HTC...). I was in a very similar situation to you in that I was a web development and was bored, I'd been playing with Android in my spare time; I got my first break by volunteering to do an android app at the company I worked for, and went from permanent employee to contractor fairly quickly after that and have been doing it ever since.
First thing to say is that if you can get your currently company to pay you to learn android and stay with them, that's a win win for both parties (you get to learn something new without a drop in salary and don't have to interview and they don't lose a good member of staff).
In terms of moving company, I don't know where you are based, but here in the UK I often see junior Android contract roles coming up for £200-300 a day. Failing that it's just a case of applying for lots of poisitions and really knowing your stuff.
What I would look for in a junior is to have read, understood and put in to practice Clean Code (https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) and Design Patterns (https://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124). I would expect you to have a good understanding of basic Java and OOP; a working understanding of MVP or MVVM (https://news.realm.io/news/eric-maxwell-mvc-mvp-and-mvvm-on-android/, https://www.linkedin.com/pulse/understanding-difference-between-mvc-mvp-mvvm-design-rishabh-software); understand threading; know about all the major parts of Android (Services, Broadcast receviers, Activities, Fragments etc); know how to write a custom view; be able to efficiently design a layout in XML and correctly apply styles and themes; understand the support libraries - what they contain, why they exist and what they are used for (and also when you don't need them); understand the difference between unit testing and integration testing and know what makes for a good test; the Gradle build system is a really nice way of defining your project build - knowing the fundamentals is essential.
A few of the main libraries I'd expect you to know and have used would be OkHttp (https://github.com/square/okhttp), Retrofit (https://github.com/square/retrofit), Butterknife (https://jakewharton.github.io/butterknife/), Picasso (https://square.github.io/picasso/) or some other image loading library, GSON (https://github.com/google/gson) or Moshi (https://github.com/square/moshi) or some other json parsing library
If you want to level up then there are loads of advanced topics surrounding Android. Any of these following topics will take a while to learn, but will be worth it and will look good in interviews and on you CV:
There's so much more - this is a large topic and it's easy to feel overwhelmed (I know I did & do) but the sheer amount of stuff to learn, but take it slowly and it'll come. The best way that I found to learn all of this stuff is to have a personal project which I was working on (I started doing an app which teaches you how to play guitar - never released it but learned so much). Get the fundamentals down and them start looking at some of the more advanced things. A good test app would be to write a Reddit client (they have open APIs: https://www.reddit.com/dev/api/) - this will get you up to speed on networking, background services (to poll the API to see if you have any messages) etc
Let me know if this helped or if you want to chat about stuff. Happy to help.
+1, don't just circle jerk and pretend you're above learning patterns before you even understand why they exist. They can be abused, but they exist for good reasons.
I strongly recommend going over Head First Design Patterns to anyone interested.
Here's a list I compiled, the list books kind of hit a wide range. I don't really have any given list of talks I like. I'll just randomly google for videos by a speaker i like or subject I'm interested in.
Books:
Watch:
Podcasts:
Blogs:
News Letter:
Misc:
Sure :)
EDIT: Added links to Amazon just in case anyone wants to see reviews.
[$1 Or More Tier]
Head First Ruby
Head First C
Head First Object-Oriented Analysis and Design
Head First SQL
Head First Statistics
[$8 Or More Tier]
Head First Javascript Programming
Head First PMP
Head First HMTL and CSS
Head First C#
Head First Agile
[$15 Or More Tier]
Head First Design Patterns
Head First Java
Head First Python
Head First Learn to Code
Head First Android Development
Here's a whole book devoted to the topic of never branching.
Some book recommendations:
Others that are great and related but not as "necessary" as the above three:
Unrelated to "better code" but still great:
Edit: these are not affiliate links :)
fwiw, bare minimum working code is often a good idea if we're talking about the amount of code to do some task :)
Design patterns are most useful in that they help you start recognizing patterns in your own code, and they show you a number of common patterns which can be useful - but it's good to keep in mind that you shouldn't force a design pattern somewhere just because it's a design pattern.
Anyway, the Design Patterns book is good, and so is Head First Design Patterns.
On the off chance you do actually want to make something complicated like a CPU, I'd recommend this book. It walks you through building a computer from scratch from logic gates to writing programs in a high level language. I think it goes without saying, but doing that sort of thing in redstone is a huge endeavor, as you've no doubt seen with the previous redstone CPUs.
Binary has no semantics - no meaning - other than being a convenient encoding of symbols. The "magic" is in how the hardware interprets those symbols.
The Elements of Computing Systems: Building a Modern Computer from First Principles walks you all the way from logic gates all the way to a working computer system with an OS and a programming language.
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
You can get a degree or you can teach yourself
The above resource is pretty good in outlining the major topics that all CS programs cover, but I would change some of their textbook and class recommendations.
I would replace the programming book/course with CS for all
Algorithms I would recommend sedgewick which is also available as a website or clrs for a more in depth review.
Those two topics will give you a very solid background. For what you want to do computer architecture, networking, operating systems, math, languages and compilers, and distributed systems aren't as important. If you wanted to expand your abilities as a programmer then you should explore those topics.
As for databases, for your purposes you may not need to learn so much how databases work as opposed to how to query databases. For this you need to learn SQL.
This should give you all the background you need in CS, now its time to start building applications. You'll probably hit roadblocks and need to research how to accomplish certain tasks, but with the above background that should be very doable.
Don't give up just yet, keep looking.
Do you have a portfolio? if not try to work on a project of your own so you can have something to show.
And if you are considering improving your java skills try work with libraries like:
With spare time I would also recommend you to read:
I love this book: http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X
It's a great read without being too math heavy. That combined with the fact that it has a great associated booksite, a Coursera course, and a couple of followup books by the same author that do go into the more mathy aspect of it, if you're so inclined, make it a great introduction to the world of Algorithms.
What OS? Linux, of course. When TPB order everything locked down, you don't want to be caught using a Microsoft OS. -- What distribution? The easy path is Ubuntu, with the Cinnamon UI, or LinuxMint 13, when issued (May 2012).
What IDE? There's lots to choose from. My favorite is "geany".
https://en.wikipedia.org/wiki/Geany
For TCP/IP protocol tutorial. Recently updated by Wright:
Stevens, "TCP/IP Illustrated", 3-volume set.
http://www.amazon.com/TCP-IP-Illustrated-Volume-Set/dp/0201776316
On human interface guidelines relevant to programming:
https://en.wikipedia.org/wiki/Human_interface_guidelines
For GNOME 2, see:
http://library.gnome.org/devel/hig-book/stable/
To develop Linux applications:
You are right. You MUST know how to program in C. When others tell you that object oriented programming is the thing, know that you can do object oriented programming in C. Avoid interpreted languages (Python, Java, and others) as a first programming language. Interpreted languages teach bad habits and hid too much of what's going on from you such that debugging becomes difficult to impossible.
However, if all you intend is "casual programming", the Python will do, if you must. It's just not the best choice first a first language if your intent is to become a "professional programmer". I use Python myself; It works for what I need to do quick and dirty.
Definitive, but for experienced programmers:
http://www.amazon.com/C-Programming-Language-2nd-Edition/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1335197606&sr=1-1
As a tutorial for someone learning a first programming language and how to program from zero:
Perry, "Absolute Beginner's Guide to C", 2ed.
-- I have not read the book, but the ToC looks reasonable for a beginner.
http://www.amazon.com/Absolute-Beginners-Guide-2nd-Edition/dp/0672305100/ref=sr_1_6?s=books&ie=UTF8&qid=1335197606&sr=1-6
OK, you don't want a full CS curriculum, but some topics in discrete mathematics are mandatory. ... Ack! Having looked over the offerings at Amazon, I believe that Epp, "Discrete Mathematics with Applications" may be the best of the lot, but at $187, it is hard to recommend without knowing your intent and interest. The reason I suggest this title is that it looks focused on application to computer science topics. It covers a number of topics that are NOT covered in many of the other titles, enough so that should you use other texts you will have spent more than the $187 that this title includes. JMHO.
http://www.amazon.com/Discrete-Mathematics-Applications-Susanna-Epp/dp/0495391328/ref=sr_1_1?s=books&ie=UTF8&qid=1335199316&sr=1-1
See also: Sedgwick, "Algorithms" -- You'll probably need it sooner than later.
http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X/ref=sr_1_1?s=books&ie=UTF8&qid=1335200153&sr=1-1
Remember that Linux OS? You are going to need some programming tools, right? If you intend to write GUI applications based on the GTK+ toolkit, then install the package "glade" or "glade-gtk". Installing a glade package will suck in over 100 other packages essential to building a GTK based GUI application. Specifying glade to the package manager is just easier that finding and installing all the other necessary parts by hand.
If you are going to do command line based UI programs, then package "build-essentials" should be adequate.
There are some other things to read:
On how to organize, grow and maintain a Linux software development project: Fogel, "Producing Open Source Software"
http://producingoss.com/
You can read it online here, but buy the book too to help support Fogel. He's gotta eat too.
On the culture of writing Open Source Software:
Raymond, "The Cathedral and the Bazaar"
http://www.catb.org/~esr/writings/cathedral-bazaar/
Linux programming is not like Windows programming.
Read and study ESR's TAOP.
Raymond, "The Art of Unix Programming"
http://www.catb.org/~esr/writings/taoup/html/
You can read it online, free. However, buy a hardcopy too. Raymond has to eat too.
Now to get really technical. What interface do you write to?
Kerrick, "The Linux Programming Interface: A Linux and UNIX System Programming Handbook"
http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200/ref=sr_1_1?s=books&ie=UTF8&qid=1335201257&sr=1-1#reader_1593272200
Beginning to focus on GNU style programming:
GNU Coding Standards
https://www.gnu.org/prep/standards/
GNU Coding Standards is more than how to and how much to indent a line or how to set braces. You will get into the topic of Make and Autotools. Make is a program to build complex softare and Autotools is about how to build a package for distribution, the package that any Unix flavor can use; it is not focused on any specific distribution. See also: "configure and make"
Enough! There's more, but I have too much time in this already for today.
[edit: typos]
You mention you have a very experienced team around you, this is your best resource. When I started my first coding job, the people around me really helped me become a much better developer. Ask for advice when you are stuck, think about best practices and sit with them and do the code reviews together. If they are writing good code then use their code as a guide for your own. You will soon learn the skills for yourself and realise that it's not as daunting as it seems as long as you can code basic programs. Something you can do to get a better feel for how your basic programs create something larger is to get them to walk you through the architecture.
One thing I did when I started was ask my team leader where I could improve and he recommended me some books. Have a look at head first design patterns, clean coder and growing-object-oriented-software. These are Java based but are applicable to any language.
http://www.growing-object-oriented-software.com/
http://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
http://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124
Ah, the age-old Drexel CS department dilemma...
tl;dr: Dr. Boady all the way if at all possible.
I've TA'd this course numerous times with numerous different instructors, including one term where I was assigned to both Dr. Nowak and Dr. Boady's sections of the course at the same time. It was kind of rough because whenever someone approached me to ask for help with the homework or go over a quiz or project, I'd have to remember to ask whether they had Boady or Nowak as the two versions of the course are very different while still ultimately covering the same material. I've also helped CS260 students in both Nowak's version and everyone else's version of the course in terms in which I was assigned to other courses, so I'm familiar with the course as taught by various instructors and the differences among them.
I sort of mentioned this last paragraph, but there are basically two versions of the course: the Dr. Nowak version and everyone else's version. The "everyone else" version has been very much influenced by Dr. Boady's changes over the past few years, so it's sort of become Dr. Boady's version moreso than everyone else's version.
I want to be clear here: Dr. Nowak is good. If you have to take it with him, it's fine, it's just less user-friendly than the alternative. The thing with Dr. Nowak though is that the's very much an old-school mathematician, maybe even more so than he is a computer scientist. That's not necessarily a bad thing; CS260 is basically a math course (not as much of a math course as CS270, however). People often forget that computer science is a mathematical discipline.
Dr. Nowak is also very set in his ways, perhaps to a fault. I think Dr. Boady may have finally found a suitable replacement for the Aho DS&A textbook (would you believe that some unscrupulous people use a PDF of this book they were able to easily find for free on the Internet rather than actually buying this??) via zybooks, so maybe every version of the course will use that from now on (and then again maybe all versions will still use Aho), but Aho is a pain in a number of ways. I get the sense Nowak is very attached to Aho as the standard textbook for the course.
Nowak's version will go through the text material in a different order than Boady, but his reason for doing so makes sense. While Boady goes through the chapters in their presented order, the first week or two of Nowak's version will cover chapters 1 & 9, skipping the 7 chapters in between (you'll circle back to them, though). This is because chapter 1 is "Design and Analysis of Algorithms" and chapter 9 is "Algorithm Analysis Techniques," so the two chapters are closely related. However, the material in chapter 9 is a bit more complicated and challenging than what you'll find in the first few chapters, which is why the Boady version covers it later in the course.
Really, the two chapters should probably be merged, but like I said: Aho is kind of a pain sometimes.
Boady's version will have more of a programming focus than Nowak's course while Nowak will require more theoretical assignments (stuff like formal proofs, or finding closed form expressions of summations, etc.). Boady's will still have theory questions and Nowak's will still have programming assignments, but the emphasis on each is different.
I vastly prefer the Boady version of the course. This is due to a number of reasons that I'll get into, but in the interest of full disclosure, one of the biggest factors is that Dr. Boady and I work very well together and I feel like we're on the same wavelength a lot of the time. He and I go way back, and one might even say that we "roll mad deep" (no one has ever said this but please feel free to start).
Dr. Boady is also incredibly good at teaching. Like, in addition to his computer science research, he's spent time actively keeping up with the research on education. One thing I find he does the best is that his labs and assignments (I don't think there are "labs" for 260 but it's been awhile) have the questions presented in a very deliberate manner such that they build off each other as you go; if you follow the order of the problems/questions as assigned, they start easy and get incrementally more complicated based on the previous question (or questions) until you reach an item that would have seemed extremely difficult if you looked at it first, but you are well-equipped to understand and solve based on the questions/problems you've already handled.
In my experience, people find that Dr. Boady is much more approachable and easy to converse with compared to Dr. Nowak (or most people, really). Dr. Nowak is a nice person and all, but I've had a few kind of funny awkward interactions with him stemming from simple misunderstandings, but nothing that made me feel like he was trying to insult me or scare me away or whatever.
Finally, one of the most important things is that Dr. Boady is much, much closer to being in your position as a student. I don't know if this is common knowledge or anything, but he did his undergrad degree at Drexel, immediately entered the graduate program here, and started working as teaching faculty as soon as he finished his PhD. He's literally taken this very course, and he took it recently enough that he remembers what it was like to be on the other side of things. A problem that I often find with older professors in general is that they're too far removed from the time when they didn't know any of the material that they're now teaching and that they may have struggled to learn it themselves and what ultimately helped them understand. When I started here, Dr. Boady was just a grad student named Mark; he understands where most of his students are at because he was in the same position relatively recently.
Anyway, I'll wrap up: he's passionate about the material and passionate about teaching and he's always actively looking for ways to refine the way he teaches his courses each term.
...but Dr. Nowak has some cool idiosyncrasies. Like, he pronounces "algorithms" as "algoritmas" and refers to the elements of a proof as "ingredients," so if you take it with Boady, you'll miss out on that ¯\_(ツ)_/¯
Hope that helps.
EDIT: I counted the chapters incorrectly which is not great in a post giving advice on computer science or math courses.
Practicing is always good, try some of these:
https://www.bloc.io/ruby-warrior
http://coderbyte.com/
http://www.codewars.com/
http://exercism.io/
http://www.rubeque.com/problems
Learning material:
http://www.rubytapas.com/ (videos)
https://practicingruby.com/
http://www.amazon.com/Eloquent-Ruby-Addison-Wesley-Professional/dp/0321584104
http://www.amazon.com/Practical-Object-Oriented-Design-Ruby-Addison-Wesley/dp/0321721330
http://www.amazon.com/Design-Patterns-Ruby-Russ-Olsen/dp/0321490452
If you don't have a CS background reading about algorithms and data structures can also be beneficial for you:
http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X
I actually had this exact discussion today. A number of people argue that type classes must have laws. I definitely share the general sentiment that it is better for type classes to have laws. But the extreme view that ALL type classes should have laws is just that...extreme. Type classes like
Defaultare useful because they make life easier. They reduce cognitive overload by providing a standardized name to use when you encounter a concept. Good uniformly applied names have a host of benefits (see Domain-Driven Design for more on this topic). They save you the time and effort of thinking up a name to use when you're creating a new instance and also avoids the need to hunt for the name when you want to use an instance. It also lets you build generic operations that can work across multiple data types with less overhead. The example of this that I was discussing today was a similar type class we ended up callingHumanizable. The semantics here are that we frequently need to get a domain specific representation of things for human consumption. This is different fromDefault,Show,Pretty,Formattable, etc. The existence of the type class immediately solves a problem that developers on this project will encounter over and over again, so I think it's a perfectly reasonable application of a useful tool that we have at our disposal.EDIT: People love to demonize
Defaultfor being lawless, but I have heard one idea (not originally mine) for a law we might use forDefault:defwill not change its meaning between releases. This is actually a useful technique for making an API more stable. Instead of exporting field accessors and a data constructor, export aDefaultinstance and lenses. This way you can add a field to your data type without any backwards-incompatible changes.Smaller business logic frameworks would be mutations and ActiveInteraction.
They would replace the operations (and parts of reform) of TB.
Personally, I wouldn't use either of them over TB, they still add complexity, but don't offer too much over self-written stuff. YMMV of course.
If you want to start simple: create POROs for your "operations" with 2 public methods - initialize and run (or call, execute, apply, process etc.). Put your logic in them, create / execute them in your controllers.
Call them services, workflows, procedures, operations, scenarios, whatever.
try to put no persistent state in them - let them do their thing, return some sort of result (
true/false, model / nil, small result object).This fulfills a number of your criteria: it shouldn't slow you down much at all, it's simple, fairly maintainable and easily unit testable.
If you would like to research a different approach, look into DDD. The Arkency book should make for a good start, with the original DDD book giving quite a bit more background information.
> I'm not coding SPAs, so I still need awesome logic for Views / Presenters.
If you liked the Cells from TB, you can use them without using the rest of TB.
If you want something simpler, use a decorator like draper with ERB or Slim.
There are some key concepts you want to get down if you really want to make the most of .NET
Design patterns are used over and over again in OO based systems. A good understanding of what they are for, and how they tend to be used will be helpful when trying to understand key framework extensions and 3d party libraries. I like to point people at Head First Design Patterns. The opinions on design patterns in this book are a bit dated and the examples use Java syntax but they are all relevant to the .NET world and will go a long way to understanding how class names and object structures are used in OO systems.
IMO One of the biggest concepts you'll need to understand in OO currently is the Inversion of Control pattern (also referred to as dependency injection) and the frameworks that provide it. Most modern .NET applications leverage some kind of dependency injection to simplify development and make unit testing and porting of classes easier.
NOTE: I understand many folks in the PHP world feel that PHP is a full OO system. While they have made strides in this area it is not a fully typed OO system. It's a procedural system twisted to provide some OO features.
This is easy, just review MSDN docs and samples. The biggest different you will see in the .NET world is a different opinion in general on casing of object and method names.
This is the part that seems the most overwhelming IMO. The language itself is fairly easy but understanding the huge amount of 1st and 3rd party libraries, frameworks and tools can be daunting. Since you come from the PHP world I am going to assume you are most interested in web based applications. What I would recommend is to pick a set of tools for your web stack and learn them. Once you understand the key pieces of a web application and how they interact you can start picking and choosing different components to meet your needs. I am going to suggest you start with the following stack to get started with a web application, this is the same stack I use for most of my clients making smaller functional websites or simple content driven systems.
Key Concepts for Modern .NET Apps
Some basic tools to help you:
Edit: Now with more links.
I think you're talking mainly about scope.
Analogy time. Let's say you have an object. A smartphone.
Your smartphone allows you to interact with it, but your interactions with the phone are limited to touching the screen, tapping icons, that sort of thing.
When you tap an icon, all sorts of things happen in the phone. From the higher-level stuff (load application, connect to internet, etc) to the lower level stuff (electronics, battery, storage read/write, etc.). You don't care about and shouldn't really have to know anything about (or have access to) that stuff. All you need is an icon to tap. A button to push.
Simple example time. The same idea applies to classes/methods/etc. within your code. You may have a class that connects to the database to retrieve a list of products for you. When you have other code using that class, all that code needs access to is your "GetProducts" method. The code using this class doesn't need to be able to establish the database connection, form the query you need, execute it, adapt the data and move it into a list -- it just says "gimme some products".
public class ProductRetriever {
private DbContext _myDatabase; // <-- Code using this class doesn't need to know about your database connections.
private void connectToDatabase() {
// DB Connection stuff goes here.
_myDatabase = new DbContext();
}
private List<Product> RunQuery() {
// DB Query stuff goes here.
_myDatabase.Database.SqlQuery<Product>("select * from products").ToList();
}
public List<Product> GetProducts() {
connectToDatabase();
return RunQuery();
}
}
In this simple example, any code that uses this class...
ProductRetriever retriever = new ProductRetriever();
...will only have access to GetProducts and nothing else.
List<Product> myProducts = retriever.GetProducts();
Suffice to say, there's a whole lot more to scope than that. Diving into protected scope and such will lead you down the path to class inheritance, etc. If you really want to get your head around Object-Oriented code, I can't recommend the book Head First Object-Oriented Analysis and Design enough. The examples they use are in Java, but it's close enough and the concept carries almost directly over.
First off, well done on getting one of your first apps out there. It's always a daunting step, especially when you're a beginner.
Some general things that will help you improve your current design and any other app you choose to create going forward:
varkeyword where applicable, using string interpolation etc, using auto-implemented properties for your classes, meaningful variable names etc).decimal.TryParse(...)instead ofConvert.ToDecimal(...), try...catch blocks, you always want to validate user-input as far as humanly possible.Algorithms (4th Edition)
The big thing you're missing is theory. You have taught yourself to be a programmer, which is great, but you haven't learned any computer science, which is a branch of math focused on whether problems can be solved and how difficult they are to solve. This is likely not particularly applicable to your day to day programming career, but when people start throwing around Big-O notation, it's useful to know what they're talking about. Also it can occasionally help you recognize that certain problems as fundamentally impossible, such as detecting whether a program will run forever or eventually halt.
The second major thing you're missing is formal algorithms training. That means that there are a bunch of useful techniques that you may not know about that may come up from time to time.
The main downside of missing out on these two things is that job interviews, especially for big programmer companies like Google and Facebook, focus heavily on them, especially algorithms. If you don't know that a hash table lookup starts at O(1) but devolves to O(N) in the worst case because of hash collisions, you may have trouble getting a job there.
The rest of what you missed was mostly either crap (UML!) or general breadth stuff that is good to know but not critical (learn how operating systems work, write a compiler, write a TCP networking stack, write a 3D renderer, etc).
I think the best way to deal with the gap is to take a Coursera course on algorithms (there's one starting next month). But that's my learning style. Another alternative would be to pick up a definitive algorithms textbook ( http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X ) and just start reading.
Good on you for looking to grow yourself as a professional! The best folks I've worked with are still working on professional development, even 10-20 years in to their profession.
Programming languages can be thought of as tools. Python, say, is a screwdriver. You can learn everything there is about screwdrivers, but this only gets you so far.
To build something you need a good blueprint. For this you can study objected oriented design (OOD) and programming (OOP). Once you have the basics, take a look at design patterns like the Gang of Four. This book is a good resource to learn about much of the above
What parts do you specify for your blueprint? How do they go together? Study up on abstract data types (ADTs) and algorithms that manipulate those data types. This is the definitive book on algorithms, it does take some work to get through it, but it is worth the work. (Side note, this is the book Google expects you to master before interviewing)
How do you run your code? You may want to study general operating system concepts if you want to know how your code interacts with the system on which it is running. Want to go even deeper with code performance? Take a look at computer architecture Another topic that should be covered is computer networking, as many applications these days don't work without a network.
What are some good practices to follow while writing your code? Two books that are widely recommended are Code Complete and Pragmatic Programmer. Though they cover a very wide range (everything from organizational hacks to unit testing to user design) of topics, it wouldn't hurt to check out Code Complete at the least, as it gives great tips on organizing functions and classes, modules and programs.
All these techniques and technologies are just bits and pieces you put together with your programming language. You'll likely need to learn about other tools, other languages, debuggers and linters and optimizers, the list is endless. What helps light the path ahead is finding a mentor, someone that is well steeped in the craft, and is willing to show you how they work. This is best done in person, watching someone design and code. Also spend some time reading the code of others (GitHub is a great place for this) and interacting with them on public mailing lists and IRC channels. I hang out on Hacker News to hear about the latest tools and technologies (many posts to /r/programming come from Hacker News). See if there are any local programming clubs or talks that you can join, it'd be a great forum to find yourself a mentor.
Lots of stuff here, happy to answer questions, but hope it's enough to get you started. Oh, yeah, the books, they're expensive but hopefully you can get your boss to buy them for you. It's in his/her best interest, as well as yours!
as a beginner you're stuck in a position where you want to learn how to do things, but also how to write them. i.e you don't only want to paint a painting, but you also want it to be pretty and admired.
for programming there's a lot of schools of thought on this subject, some guys prefer test-driven development, others domain-driven design.
some think comments outside of method parameters are good coding praxis, others think it's a code-smell because if you have to explain your code you probably wrote it in a way that makes it difficult to understand.
some think patterns are for hipsters, others are of the correct opinion (ahem) that they are standardised solutions for common problems.
all in all, if I could go back in time 15 years when I started programming, I would read the following if they were available at the time:
https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
Domain-Driven Design is the concept of breaking your code into logical real world units and bundling your code around these objects so that it makes sense to program if you understand the real world your program is mirroring. i.e if you're making a fruit shop program, you might have a fruit seller, a register, a fruit warehouse, a process to deal with ordering fruit etc.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Clean code talks not so much about the architectural patterns (outside of test-driven development) but rather what's good and bad about code at it's core. i.e
if(fruitStand.Amount < 5)
{
fruitHelper(fruitStand, 3434)
}
vs
if(fruitStand.Amount < dailySoldAverage)
{
OrderNewFruit(fruitStand, wholesaleDiscountCode)
}
outside of that, I think you'll find a lot more resources by simply researching the concepts these guys talk about. programming is constantly changing, as long as you have the fundamentals in place as these guys talk about you're golden as long as you're willing to learn.
This reads pretty much exactly like Hacker's Delight except that the book focuses on the assembly behind this instead of the C code in front.
Also relevant: Hackers Delight, (Amazon link)
You've already done the first step: admitting that college can only teach the fundamentals while the rest of the things you need to know, you will learn while working.
With that out of the way, here's the next step: apply the Joel Test to your new employer.
If it gets an 11 or 12, you'll be fine. Find a senior developer there to mentor you and you'll be a decent software engineer in 1 - 2 years.
Otherwise, while you might learn a lot of new stuff in your first job, they might be inadequate, outdated, or outright incorrect. In this case, plan an exit strategy ASAP so that you can leave to another company that has a much higher score in the Joel Test. In this fast paced software industry, it makes no sense to spend 5 years in a company where you'd only get to grow the same amount as another guy who just spent 6 months in a better company.
Next step: read. No, not those "Teach yourself [insert language that will be deprecated in 2 years] in 24 hours" books - find the books that teach software engineering, lessons that don't get outdated. Here's the usual suggestions:
Finally, if you have free time, find a local user group or open source community and join them. Not only will you learn fundamentals like version control and automated testing, you'll also be up to date to the latest trends in the industry. Because of this, high school/college students who are active in these communities have a great advantage over their purely academic classmates, not to mention the connections they get in the industry allow them to be employed faster.
Three CS fundamental books in the order I'd suggest someone read them if they don't have a background in CS.
Elements of Reusable Object-Oriented Software - "Gang of Four". My preferred way to consume this book is to read it lightly, understand the basics of the patterns, and then come back to them individually when you encounter them in the wild or think you want to employ one of them.
Then there are these books that aren't really "CS books", but are geared more twoards practitioners.
Can't go wrong with Introduction to Algorithms
Another popular algorithm book is Skiena's Algorithm Design Manual
Another one suggested by one of my professors is Algorithms by Robert Sedgwick
Even more formatting fun!
By the way, thank you for this list.
I don't know about "beginner", but I was introduced to a lot of the key ideas when I took my Computer Architecture course in college, using a book like this.
Emulator 101 should be a good guide getting started, and other posts like Imran Nazar's about emulating the Game Boy in Javascript would be useful.
Chip-8 is a simple starting point (just a few operations, very simple architecture, only expects to run at about 500-1000 Hz, there are timers but not really interrupts, etc). Makes sense that it's simple and slow; it's actually a VM that ran on some microcomputers in the latter half of the 70s.
Space Invaders (the arcade game) has a more complex CPU, straightforward graphics and audio, and predictable timing on the interrupts.
Game Boy is a cleaner design than the NES, and the CPU can very nearly be adapted from the Space Invaders one. It introduces interrupts, interrupt priorities, memory bank-switching, more complex graphics and audio.
NES is similar to the Game Boy in some ways, but I feel like the quirkiness is even closer to the surface. Fewer interrupts, split memory map between CPU and PPU (the graphics chip), and a horrendous number of bank-switchers used in different games.
A lot of Sega's hardware, the SNES, or even something more obscure might make sense at this point.
My own path, so far, has been NES, started Game Boy (took a small break to build Chip-8), then finished Game Boy, added Color. Took a bit more time, then jumped into Game Boy Advance, which is my current thing (and being fair, I've taken a lot of breaks...I think I was seriously looking into GBA over a year ago).
Algorithms, Design Patterns, VCS, being familiar with typical CS interviews questions and something that will be really needed
Some Books:
For Algorithms:
http://www.amazon.co.uk/Algorithms-Sanjoy-Dasgupta-ebook/dp/B006Z0QR3I/
http://www.amazon.co.uk/Algorithm-Design-Edition-published-Springer/dp/B00E28CR4I/
http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/
Design Patterns:
http://www.amazon.com/Design-Patterns-Explained-Perspective-Object-Oriented/dp/0321247140/
http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124/
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/
http://www.amazon.com/Design-Patterns-Dummies-Steve-Holzner/dp/0471798541/
Interviews:
http://www.amazon.com/Cracking-Coding-Interview-Programming-Questions/dp/098478280X
http://www.amazon.com/Programming-Interviews-Exposed-Secrets-Landing/dp/1118261364/
Algorithms by Robert Sedgewick. I find it clearer and easier to understand than Intro to Algorithms (CLRS)
Strictly in order.
Head First Programming
Head First Java
Effective Java
Head First Design Patterns
Head First Software Development
<http://developer.android.com/training/index.html&gt;
You are welcome!
I don't really have many good resources for you. I don't read a lot of technical books or websites/blogs outside of my day-to-day job. I've heard some pretty amazing things about Site Reliability Engineering and Effective DevOps, but I have yet to read either of them.
Overall, as you move forward in your career, I would encourage you to learn as much as you can about the ecosystem your code lives in. A lot of people who go into DevOps have really broad and comprehensible knowledge about the entire stack, all the way from networking and servers, to writing code, to building/deploying/hosting that code, to performance tuning that code, to logging and monitoring issues within the code, etc. Some developers really get stuck on "well, I've written the application, so I'm done, right?" but really there's a lot more to it and that's what DevOps people know and do.
Basically any SRE advice for a normal service but replace/compliment HAproxy / nginx / ingress controller / ELB with the Tor daemon / OnionBalance.
I run Ablative Hosting and we have a few people who value uptime over anonymity etc and so we follow the usual processes for keeping stuff online.
Have multiples of everything (especially stuff that doesn't keep state), ensure you have monitoring of everything from connections, memory pressure, open files, free RAM etc etc.
Just think of the Tor daemon onion service as just a TCP reverse proxy, with load-balancing capability and then follow any other advice when it comes to building reliable infrastructure;
Once you've got to grips with running a reliable service then you can start layering your Onion reverse proxy / load balancing on top.
All of this aside, check /u/alecmuffett's "Onions that don't suck" repo for examples that are both well setup and stable.
TL;DR; Tor is just a TCP reverse proxy with load balancer capabilities go learn some DevOps dodads
Edit: As per Alec's comment - clarify that Tor is technically a reverse proxy with load-balancing capabilities rather than a straight up TCP load balancer.
I learned most of what I know from Robert Sedgewick, whose prose is exceeded in clarity only by his diagrams:
https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X
Steve Skiena is also excellent, and writes a bit more accessibly:
https://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1849967202
You can usually find these on the shelves of a university library.
For those interested, Coursera is hosting an Algorithms course taught by Kevin Wayne and Robert Sedgewick, authors of a fairly well received Algorithms book.
I currently work with the Axon Framework. The community isn't that great, but the inventor is fantastic. He's always willing to help (at least it seems that way). I would suggest looking around the internet at things such as CQRS, Event Sourcing, and DDD (Domain Driven Design).
Since you asked for resources I would suggest Vaughn Vernon. Also, my coworker has a giant list of resources, here you go.
DDD Stuff:
Axon Stuff:
Grey and Meyer?
Just curious - what have you got against Razavi, Sedra/Smith, and AoE that can be satisfied by another book? Those three cover quite the spectra of ECE textbook style.
An alternative to the gang of 4 book which is easier to digest is the head first guide
Head First Design Patterns https://www.amazon.co.uk/dp/0596007124/ref=cm_sw_r_cp_apa_i_jGIzDb57C3ACR
This is a pretty good book about design patterns.
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
I generally agree, but the problem with patterns is some folks try to shoehorn everything into a pattern sometimes turning something simple into something more complex than it needs to be.
&#x200B;
I find that following SOLID with YAGNI at the back of your mind tends to be what seems to work best for me
Along the lines of patterns: I'd recommend Head First Design Patterns
These are great suggestions. The three books I typically give devs early (that fit in well with the two presented here) are:
Refactoring by Martin Fowler
This is a list of patterns of common refactoring a and how to do them safely. It’ll help you recognize transforms you need to make in your code as it changes.
The Pragmatic Programmer by Dave Thomas and Andy Hunt
This is a great guidebook for how to get better at being a software engineer. Essential read.
And while there are lots of options for design patterns books...
Head First Design Patterns was the one that helped me internalize them. Even if you aren’t writing much (or any) Java, the method of teaching is hugely valuable.
Yes, there is also Head First Design Patterns which is also very good.
> Look for a book on object oriented programming
For this I recommend both Head First Java and then follow that up with Head First Design Patterns.
Fungus Cave
Github repository, screenshot.
It has been over a month since I finished my last project, Cursed Souls. Now I am working on a new Unity game, Fungus Cave. There are not so many things to talk about the game itself yet, so I would like to share the books I have read about C#, data structure & algorithms, and Unity.
C# 7.1 and .NET Core 2.0 is my C# textbook. It explains everything step by step for beginners. Although you need a PhD in math to create Dwarf Fortress, to learn data structure & algorithms is not so demanding with the help of these books:
After that, I browse articles in RogueBasin to learn about: time system, dungeon generation, pathfinding, FoV and AI.
There are tons of books on Unity. I cannot tell which one is the best, but two of them which I have bought are well worth the money:
Save/load system and coroutines are two topics that I care about but still do not understand after reading these books. So I googled around a bit and found something in addition to Unity tutorials:
That's all. It took me about three months to learn all these things. I hope this book list would be helpful to other developers. Happy coding!
My professor used Signals and Systems as the textbook. Since the professor can't speak English and the lecture was boring, I decided to skip the class and watch online lectures instead. At the final, I found out the exam was copied from other schools and translated into English.
One time, I failed a class because the professor lost my paper. the paper is still to be found.
Chinese education loves math riddles. Sometimes, they will give out riddles for students to solve. I can't possibly solve those riddles in the limited time without coming across them before hand.
I tend to skip classes and read textbooks by myself. Chinese textbooks are poorly organized and work load was heavy. I always found that the final exam questions were not covered by the book.
In C programming class, students are required to answer ambiguous questions and write snips by hand. It was ridiculous. Students who can't write any program by themselves could earn a perfect score. I just merely passed.
If I lived through boring lectures, made notes on what types of questions would be on the exam, had previous final papers on my hand, and made the professor know my face, I could have passed. If I did a bunch of exercises and understand the material perfectly, I might have passed (since I never got to see my papers, I am not able to make any conclusion). For some subjects, since I kinda understand the material, I could have failed but I got a pass. For some subjects I had absolute confidence, I failed.
I am responsible for my failing. If I had the chance to do it again, I would choose not to waste my time in CQU.
The Humane Interface: New Directions for Designing Interactive Systems by Jeff Raskin, cognitive psychologist and "Father of the Macintosh". This book fundamentally changed the way I think about designing software.
Jeff Raskin's book The Humane Interface: New Directions for Designing Interactive Systems is a classic source of inspiration. He was the original creator of the Apple Macintosh project, before Steve Jobs took over.
It's dated, but Methodology of Window Management is an interesting read to see how different and diverse user interfaces were before the sudden "standardization" of definitions and expectations that happened when the Mac came onto the scene.
After 1984, everyone tried to imitate the Mac, which itself was an imitation of some of the stuff developed at Xerox PARC. I agree with what Raskin wrote in Wired in 1993: "the first popularization of those ideas [was] on the Apple Macintosh in the 1980s, [and] we have had almost nothing really new in interface design."
Bill Buxton put it well: it is an unworthy design objective to aim for anything less than trying to do to the Macintosh what the Macintosh did to the previous state of the art.
You're essentially asking for a computer science class on algorithms. I would recommend:
Its not advertised but it uses Java for the examples.
http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X
Download Virtual Box.
Download a few Linux Distros - Ubuntu, CentOS, etc. Ubuntu is rather user friendly. Get the server version, not desktop. (Or get both, but you want experience with the command line, and the server version will force you to work with the command line.)
O'reilley books are great. Very dry, but reliable sources of info. Go "used" for now, as they can get expensive when you buy too many.
Learning the Unix OS is a good intro.
Also, this book is a large overview of linux sysadmin: Essential System Administration by Frisch
A Bash book would help, as well.
Oh, and the "man" command. On the command line, run "man anycommand" to bring up manual pages on any command. You can run "man man" or "man bash" to get started.
Best of luck!
Edit: typo
Head First Design Patterns: A Brain-Friendly Guide
A relatively unique methodology of approaching design patterns (using Java examples). Understanding design patterns will transform both you and your code.
EDIT: Adding my comment below to my comment here for better visibility and description of the book:
> It can absolutely be read as an introductory book! I would recommend going into the book having a foundation in an OO language, such as Java or C++.
> This was the "textbook" we used in my Object-Oriented Design course; however, the great part about this book is that it reads more as a "narrative" than a traditional textbook. I definitely think this is the best book for learning about design patterns. The GoF book should be used as a reference, after you understand them better.
> All I can say is do not judge a book by its cover, and in this case I mean it literally. I think they are trying to be ironically cool by using stock photos on the cover and within the book. It seems odd to be reading through a "serious" book that look like that, but believe me when I say it will be an eye-opening experience.
Uhm, I would first start with a complete introduction to OOP. This book:
http://www.amazon.co.uk/Thinking-Java-Bruce-Eckel/dp/0131872486/ref=sr_1_1?ie=UTF8&amp;qid=1451750882&amp;sr=8-1&amp;keywords=thinking+in+java
helped me a lot. Once you go through with it, you should have a pretty solid understanding of OOP and Java.
Also I cannot stress enough how important this thing is, many people seem to neglect it nowadays:
http://www.oracle.com/technetwork/java/codeconventions-150003.pdf
I recommend following books once you understand Java more :):
Effective Java by Joshua Bloch:
http://www.amazon.co.uk/Effective-Java-Second-Joshua-Bloch/dp/0321356683/ref=sr_1_1?ie=UTF8&amp;qid=1451750978&amp;sr=8-1&amp;keywords=effective+java
Head First - Design Patterns by Eric Freeman:
http://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=pd_sim_14_2?ie=UTF8&amp;dpID=61APhXCksuL&amp;dpSrc=sims&amp;preST=_AC_UL160_SR138%2C160_&amp;refRID=1J4FWDFZDD8XERKQEY2Q
Clean Code by Robert C. Martin:
http://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_sim_14_3?ie=UTF8&amp;dpID=51oXyW8WQwL&amp;dpSrc=sims&amp;preST=_AC_UL160_SR124%2C160_&amp;refRID=1J4FWDFZDD8XERKQEY2Q
Learn by experience and by reading is probably the way to go. The gang of four's design patterns is still the de-facto standard:
http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
I really love this book for Java design patterns though, fun to read and really informative:
http://www.amazon.ca/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1333263240&amp;sr=1-1
Then it's a matter of knowing when and where to apply them, which is a harder problem and just an experience thing I'd say.
My advice, don't worry about coding or experience in this or that solution.
Read, Read, Read!
Learn the discipline, the fundamentals, know what DevOps is.
Start with this:
https://www.amazon.com/Site-Reliability-Engineering-Production-Systems/dp/149192912X
ilk olarak kolay gelsin.
Stanford ve MIT'in online course'lari var itunes university'de ordan bakmaya basla istersen.
Internetten egitimini sevdigin okullarin syllabus'unu alip ordaki kitaplardan calismaya baslayabilirsin zaman kaybetmemek icin. Istersen sana sirali kendi transcriptimdeki dersleri PM olarak atabilirim.
Okulundan aldigin .edu emailini cogu programi bedava kullanmak icin kullanabilirsin. (github inanilmaz bi pack veriyor, %100 suistimal etmeni tavsiye ederim)
Kitap oku ve bol bol kod yaz. Boktan olsa, bozuk olsa bile yaz. Kagit kalemle de yazmaya cekinme (is basvurularinda seni beyaz tahtaya cikaracaklar malesef debugger/syntax checker olmicak)
aklima gelen standart kitaplardan en onde su geliyor:
Bilgisayar temel bilgileri icin de Computer Organization
Eger lise bilgilerinden korkuyorsan cok inanilmaz bi matematik yok (sektorune gore degisebilir tabi). Lineer Cebir (image processing/game-development vs.) ve Olasilik (AI, Machine learning, data analysis vs.) bilgilerini tazele. Eger machine learning falan yapmak istiyorsan ilerde olasilik bilginin guclu olmasi gerek.
Cok net bi cizgi izlemene gerek yok. Gerektikce ogrenme politikasi benden yana cikti su ana kadar ama bu tartisilir.
baska bisi olursa cevap vermeye calisirim.
Low level stuff is pretty academic. You need textbooks just to get started.
These were my college textbooks (I have earlier editions):
Computer Architecture: A Quantative Approach
Computer Organization and Design: The Hardware/Software Interface
The material is pretty dry but if you can slog through it you will gain good insight into how and why chips and systems are designed the way they are.
Below this level is logic gate design where if you don't have a background in semiconductor physics you'd never get through it.
> Textbooks aren't much of a thing because so much information is available online and technology changes so fast.
That's
and I'm not just pointing out that those books exist. They're really good resources!
the classic signals book is Signals and System by Alan Oppenheim.
https://www.amazon.com/Signals-Systems-2nd-Alan-Oppenheim/dp/0138147574
Pick up these books:
Just remember that the goal of a good architecture is to provide value, but maintain high quality of code that is easy to maintain and change. Separation of concerns , loose coupling, testability, maintainability and scalability are major points to look out for .
Books
Stuff to watch
Blogs
Other resources
Algorithms by Sedgwick and Wayne.
Yes, she uses Java and this book.
>would that mean, technical, that you have multiple Order classes based on context?
Yes. Generally you have a "source" domain where the order originates and the order in other domains generally build their order off of the original order one form the "source" domain.
>If so, do they have their own DAL or do they get mapped differently?
Similar to microservices, its recommended that each domain has it's own persistence mechanism. If you've got really big contexts, especially if they have multiple Order types, then you're probably doing it wrong. The ultimate idea is that an Order in each domain is allowed to evolve independently from any other domain.
>I haven't found a "from 0 to done" example yet
From my experience that's kinda hard, just because there's a lot that exists outside the code with DDD. You need to have the documentation and knowledge from the subject matter expert to really understand why certain things are structured the way they are and why certain terms might be used over others.
As far as resources go, the obvious answer is to go directly to Eric Evan's book, but I also feel that's a lot to chew and digest if you're just getting into the topic. My recommendation is to actually start with Vaughn Vernon's Domain Driven Design Distilled, as it gives a higher level overview and description of the concepts of DDD rather than diving into the deep end like Eric's book. From there, I'd either go to Eric's book or to Vaughn's other book, Implementing DDD. Once you get a lot of the concepts, I've found that Patterns, Principles, and Practices of DDD is a good book to get a handle on the code, architecture, and infrastructure implications of DDD.
If you're the "intellectual type", buy a really high quality graduate textbook like (G&M) and read it cover to cover. Work all the problems and save your solutions, to review and update 9 months later. And again 36 months after that.
If you're the "pragmatic type", build things. Lots of different things - don't limit yourself just to guitar amps or radio receivers or test equipment or stereo gear or video studio electronics or alarm systems or automotive electronics or Arduino shields. Do all of them! Work your way through books of schematic diagrams like Horowitz and Hill, Pease, Camanzind and build, build, build.
If you're the "voracious type", do both.
Google "c# github projects for beginners". Theres a whole bunch of interesting stuff out there. You could also download/fork a github repo and try to extend a project, or build on top of it.
I think this repo has been posted here before, but learning design patterns is really useful prior to designing something from ground up. https://github.com/Finickyflame/DesignPatterns
Here's a good beginner's book on design patterns. https://www.amazon.com/dp/0596007124/ref=cm_sw_r_cp_apa_i_FmHsDbGWQ0NTJ
https://www.amazon.com/dp/0201633612/?tag=stackoverflow17-20
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
And you could check stack overflow for question on general programming books. I would always go for a general concept
functional programmingoverhow to functional programming in haskell.But I'll be perfectly honest, I'm a victim of the curse of knowledge so I honestly don't know how one should start. What I do remember is that I had huge problems with syntax (how do I tell language X to do a
for (Employee e in employeeList), how do you write a switch and stuff, why would I ever need a ternary operator, and like that.But once you master the basics of how to write x, y and z in your preferred language, you absolutely need to understand design patterns, you absolutely need to understand how code is supposed to be written, you absolutely need to understand data structures, you absolutely need to understand inheritance and polymorphism, you absolutely need to understand lambdas and functional programming.
Then you can get to the more "neat" stuff like the benefits of having immutables, and "job specific stuff" like how to solve race conditions in threading; sockets and web communication, etc.
Depends what you want to learn. Some of my favorites are
This a good list to get you started :) most of my favorite books are not language specific.
I'm a pure math guy but Algorithms by Sedgewick & Wayne is one of the best textbooks I've ever read.
Code: The Hidden Language of Computer Hardware and Software
Clean Code: A Handbook of Agile Software Craftsmanship
Code Complete: A Practical Handbook of Software Construction
Algorithms
Types and Programming Languages
While you said books haven't helped, give this one a try: http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124
This website is pretty good also: http://sourcemaking.com/design_patterns
The book, Head First Design Patterns, is actually pretty good.
You could also read the book that started it all, Design Patterns: Elements of Reusable Object-Oriented Software. Although good, it is a dull read - I had to force myself to get through it.
Martin Fowler is also really good, in particular, I thoroughly enjoyed his book Patterns of Enterprise Architecture.
If you want more of an MS/.NET slant of things, you should also check out Dino Esposito. I really enjoyed his book Microsoft .NET: Architecting Applications for the Enterprise.
My recommendation would be to start with the Head First book first, as this will give you a good overview of the major design patterns.
Effective Java
Head First Design Patterns
http://www.theserverside.com/
http://stackoverflow.com/questions/tagged/java
If you're trying to learn any assembly language (not specifically x86 based) I know there are several books out there for MIPS. I've used [Computer Organization and Design] (http://www.amazon.com/Computer-Organization-Design-Fifth-Edition/dp/0124077269/ref=sr_1_1?ie=UTF8&amp;qid=1396238245&amp;sr=8-1&amp;keywords=computer+organization+and+design) by Patterson and can say I found it very helpful. On top of that, [MARS] (http://courses.missouristate.edu/kenvollmar/mars/), a combination IDE/emulator can be used with it (and is open source/free).
In the interim, I suggest the following books:
&nbsp;
As for the coding books, I suggest you pick one up on Python or Java - I'm personally biased towards Python over Java, since I think Python's syntax and code style looks nicer, whereas Java makes you say pretty much everything you're doing. Both programming languages have been out for a long time and see widespread usage, so there's plenty of resources out there for you to get started with. Personally, I'd suggest going with this book for Java and this book for Python, but if you go to Coursera or Codecademy, you might be able to get better, more interactive learning experiences with coding.
Or you can just skip reading all of the books I recommended in favor of MIT's OpenCourseWare. Your choice.
Not sure about EE-related topics, but for CE you're almost guaranteed to use these textbooks:
And of course, the most important and useful textbook of them all for almost anything coding-related.
Disclaimer: I don't know the EE stuff very well, but I do know enough to explain everything that comes after.
Here are two explanations of how you build logic gates from transistors: a simple one and courtesy of the EE StackExchange, a more technical one. (The value of an input and output is taken relative to V-/GND.)
Before you can build a CPU with logic gates, there are two concepts you need: (1) Boolean algebra and (2) memory cells.
----
If you look up Boolean algebra, you're going to get a lot of results that only math majors really understand (e.g. the Wikipedia page). To simplify it all, Boolean algebra is essentially the field of study that asks "if I only have two values to work with, TRUE and FALSE, what kind of math can I do?" Notice that TRUE and FALSE map neatly to 1 and 0 (hello, binary math!) as well as HIGH and LOW (V+ and 0V).
This means that you can make all sorts of circuits, like binary adders, multipliers, dividers, and so on. (Subtraction involves some extra logical tricks.)
At this point, what you essentially have is the ability to create any function.
----
Now what we need is some way to remember data: that's where memory cells come into play. (This is basically your RAM.)
The primitive form that gets taught in introductory EE courses is the flip-flop circuit: a circuit with two stable states. The stable part here is important: it means that if such a circuit enters this state, it will not leave this state until an input changes. (Similarly, if such a circuit enters an unstable state, generally, it will eventually transition into a stable state.) There are a lot more ways to construct memory cells, of course, but flip-flops are a simple way to see how you can store and manipulate data in a circuit.
With memory cells and Boolean algebra, you can now build state machines. Again, if you google this you're going to end up finding a lot of academic technical nitty-gritty, but at its most basic, a state machine has a finite number of states (A, B, C, ...) and each state corresponds to some function of its inputs.
----
The canonical example is a vending machine (keep in mind, all the electromechanical stuff is abstracted away here - we're only thinking about the control logic).
Let's start with a really simple vending machine. It only accepts $1 coins, it only dispenses one type of soda, and all sodas are $1 each. It's not our job to worry about restocking or counterfeit money or whatnot: our job is just the dispensing logic circuit. We know we're going to have one input and one output: an input for "is there a dollar coin being inserted" and an output for "dispense one can of soda". And if we think about it, the circuit should only have two states: dispensing a soda and not dispensing a soda.
That's pretty simple, then: we use one memory cell, to distinguish between the dispensing and not-dispensing state. The output will always reflect our internal state (i.e. output goes HIGH when dispensing, LOW when not dispensing); and if our input goes HIGH when we're not dispensing, we transition to dispensing, and no matter what our input is when we're dispensing, we transition to not dispensing.
Now we can start adding some complexity to our vending machine: let's accept pennies, nickels, dimes, and quarters too. How about dollar bills? To deal with this, clearly our state machine is going to need some kind of internal counter for how much money has been inserted. We're also going to need logic to compare how much money has been inserted to how much soda costs right now ($1), and also logic to dispense change.
But not everyone's a fan of Generic Soda™ so we're going to need some variety. Now we need a way for people to choose a soda. And since some people are snobs and want pricey stuff - they're willing to pay $2 for their canned beverage of choice (gasp! shock! horror!) - we need to add logic to handle different prices.
----
CPUs are built up much in the same way like the hypothetical vending machine above. A program is supplied as input, in the form of a list of instructions, and the CPU is basically a really big state machine that goes through the program line-by-line.
Explaining the details of how a basic CPU is designed is a full undergraduate course (Computer Organization/Architecture, usually), and seeing as how I've already outlined its prerequisite (Digital Logic) above, I'm going to stop here. The text I learned from was Patterson and Hennessy's Computer Organization and Design (you can find free PDFs of older versions floating around if you just google it).
----
Aside: if you have Steam and are interested in assembly-level programming, I've heard great things about Shenzhen I/O.
It seems like you are looking for a textbook on computer architecture?
If so, this book would be pretty standard.
This is the grad school "bible" in (digital) signal processing, heavy on linear algebra and probability:
http://www.amazon.com/Mathematical-Methods-Algorithms-Signal-Processing/dp/0201361868
Undergrad "bible" (mostly just a fourier analysis approach; useful for linear, time-invariant, causal systems):
http://www.amazon.com/Signals-Systems-2nd-Alan-Oppenheim/dp/0138147574
You can read a good deal more about the Canon Cat and Jef Raskin's design philosophy generally in Jef's book: The Humane Interface.
I didn't realize it was written in Forth, however. Great link.
https://www.amazon.com/Computer-Organization-Design-MIPS-Fifth/dp/0124077269
Signals & Systems 2nd Edition by Oppenheim, Willsky and Nawab is the book I'm using and I've found it to be quite enjoyable reading it. Probably also helped me ace the midterm as well.
EDIT: Here's the Amazon page: http://amzn.com/0138147574
>I didn't really get that much coding experience in actually implementing my own versions of the data structures that were covered.
Nothing's stopping you, don't need a book to do that. If you learned the theory and are familiar with the ADTs it should be a piece of cake. I actually think it's better for classes to stay abstract and teach more theory - too many students get caught up in languages, but these concepts are higher level than that.
This one is solid but if you are looking for something to walk you through implementing them then you should just use online resources. This site has implementations and should cover everything you need and more (plus it's free)
Code Complete: http://www.cc2e.com/Default.aspx
Data Stuctures and Algorithms: http://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237
Read lots of code and read books to get multiple viewpoints. This is a deep topic which will require more than superficial online reading.
Check this out.
Books I have found useful:
My blog about software architecture: http://www.tutisani.com/software-architecture/ (may not be for very beginners but I hope that it's able to communicate important topics).
I'd also suggest reading the classic book about design patterns (a.k.a. Gang of Four): https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_3?crid=1XRJO0L09LHLY&keywords=design+patterns+elements+of+reusable+object+oriented+software&qid=1557502967&s=gateway&sprefix=design+patterns%2Caps%2C162&sr=8-3
There are several good thought leaders in this direction, specifically Martin Fowler (https://martinfowler.com/) and Eric Evans (he does not write much online, but his book is great - all about modeling properly): https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
&#x200B;
I'm big on modeling, objects, etc. so reply back if any questions.
I’m taking Data Structures and Algorithms right now. It’s definitely not an easy class so it’s very ok to struggle. I’m not sure which language are you guys using, but if you’re using Java, then this is an amazing book that starts from the basics! https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=mp_s_a_1_4?ie=UTF8&amp;qid=1536420166&amp;sr=8-4&amp;pi=AC_SX236_SY340_QL65&amp;keywords=algorithms&amp;dpPl=1&amp;dpID=41%2BpJNrGujL&amp;ref=plSrch
On the other hand, you have to build things by your hand in order to understand them. Don’t worry about how quick you get the concepts, it’s ok to meditate on them. After all, what took scientists years to build is not supposed to be understood in an hour. Take your time and good luck!
https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X
I'm going through this book. It's the best.
Sure! There is a lot of math involved in the WHY component of Computer Science, for the basics, its Discrete Mathematics, so any introduction to that will help as well.
http://www.amazon.com/Discrete-Mathematics-Applications-Susanna-Epp/dp/0495391328/ref=sr_sp-atf_title_1_1?s=books&amp;ie=UTF8&amp;qid=1368125024&amp;sr=1-1&amp;keywords=discrete+mathematics
This next book is a great theoretical overview of CS as well.
http://mitpress.mit.edu/sicp/full-text/book/book.html
That's a great book on computer programming, complexity, data types etc... If you want to get into more detail, check out: http://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/0534950973
I would also look at Coursera.org's Algorithm lectures by Robert Sedgewick, thats essential learning for any computer science student.
His textbook: http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=sr_sp-atf_title_1_1?s=books&amp;ie=UTF8&amp;qid=1368124871&amp;sr=1-1&amp;keywords=Algorithms
another Algorithms textbook bible: http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/ref=sr_sp-atf_title_1_2?s=books&amp;ie=UTF8&amp;qid=1368124871&amp;sr=1-2&amp;keywords=Algorithms
I'm just like you as well, I'm pivoting, I graduated law school specializing in technology law and patents in 2012, but I love comp sci too much, so i went back into school for Comp Sci + jumped into the tech field and got a job at a tech company.
These books are theoretical, and they help you understand why you should use x versus y, those kind of things are essential, especially on larger applications (like Google's PageRank algorithm). Once you know the theoretical info, applying it is just a matter of picking the right tool, like Ruby on Rails, or .NET, Java etc...
I recommend learning about Domain Models (Crafting Wicked Domain Models by Jimmy Bogard is highly recommended) and Domain-Driven Design (this Pluralsight course is the best introduction in my opinion).
Though the sample code in those videos is in C#, it should be straightforward to translate it into PHP. Watching those videos and reading books like Implementing Domain-Driven Design have taken my coding to a whole new level.
For language specific stuff like c++ I'd suggest:
https://www.toptal.com/c-plus-plus/interview-questions as a pretty good quick review. Going through c++ primer (or whatever book you learned C++ from) and just touching on all the topics that you don't remember can help a lot.
What helped me with design patterns is head first design patterns. Even though that book seems very 'intro' it has helped me pass all the design pattern question I've ever gotten. I think just visitor, singleton and MVC are the most popular interview design patterns. The more canonical 'gang of four' book would be: this.
For just practice tech interview problems that you'll see on silicon valley, big4 tech interviews, the most popular site is probably leetcode (hackerrank, or top coder or even codewars are pretty good sources too). The most popular book (as mentioned many times) is Cracking the coding interview.
Just grinding out problems on leetcode, you'll probably learn enough to pass most tech interviews after about 100-200 questions (if you've never done this before, less if you have).
Before/during your leetcode practice I've written a series of tech interview tips to help you check on your fundamentals (you can check it out at fizzbuzzed.com). I try to go over the questions I see people failing most often. I'm also trying to help readers so would love to help you if you run into problems.
I also think you should ask the recruiter the style of interview you'll be having. If you are on the whiteboard then you should practice on it before hand (whiteboard interview tips here.
Pragmatic Programmer, Clean Code, and Head First Design Patterns come to mind right away. They're 3 of my favorites.
There's also Design Patterns by the Gang of Four. That's a lot more dense IMO than Head First, but it's fantastic material.
Since you're looking to jump ship and start interviewing, take a look at Cracking the Coding Interview. That will prepare you for any questions you run into during the process.
It's probably also worth brushing up on Algorithms and Data structures.
That is a lousy professor. You want to learn more? Nope, don't think so.
You could find open source projects that are written in java. Or maybe check out the source code for OpenJDK (library implementation).
But better yet, pick up a book. You have the popular book Clean Code by R. C. Martin that covers how to write clean and maintainable code. Or maybe the book Head first: Design Patterns by that covers common designs used to make adaptable and reusable code.
But your professor has one point. You should not get lost into code design when still learning the basics. So remember to focus on what you learn in class! :)
It depends on what I'm reading. 20 for the average book is about what I can read. I've had things like What Every Programmer Should Know About Memory that I could only do 5 pages at best and things like Head First Design Patterns where I could do 40 or 50
An interesting side note is that I've also been reading books like Thinking, Fast and Slow that basically say that we have a finite amount of mental will power. We can only focus on a difficult task for so long before we run out of steam. The only way we know to improve focus this is by maintaining decent glucose levels. So you might be able to improve your limit by having a snack or breaking for something to eat.
I've also been reading Seach inside yourself. It's book on meditation written by a programmer at Google. I'm hoping to improve my focus with meditation. It might also let you bump up your number number of pages per-day or at least let you settle in to reading faster
I find the Head First Design Patterns book to be really helpful. The code samples are in Java, but for the most part the examples are very readable even if you're not familiar with the language. Most of the good stuff is in the explanations, as opposed to the specific implementations shown in the code samples.
So this is what I would consider the "Core" reading list for anyone interested in programming games. None of this is really game specific though. These are just the fundamentals you need in order to be an effective Software Engineer.
Learn about...
C++ syntax: Programming: Principles and Practice Using C++ by Bjarne Stroustrup
Software Engineering: Code Complete by Steve McConnell
C++ gems: Effective C++ by Scott Meyer
Software Teams: The Mythical Man-Month by Frederick P. Brooks Jr.
Why we love Joel: Joel on Software by Joel Spolsky
Problem Solving: The Pragmatic Programmer by Andrew Hunt
Common Code Solutions: Head First Design Patterns by Eric Freeman
Pearls!: Programming Pearls by Jon Bentley
I'll do a supplemental on this in a few days that dives into specific topics related to engine development. All of this is generic enough that it will help you regardless of what you do. You'll notice that very little here is actually language specific. Almost all of this is about the art of making software and process of working with a team. These 8 books alone will make you think about making software in a whole new way.
It will help if you know the basic catalog of OO design patterns (observer, decorator, factory, etc.). Then, if your "very experienced, knowledgeable leader" is kind enough to name things appropriately, it should be a lot easier to understand what's going on.
Head First Design Patterns has a very fun approach, teaches the basic patterns while also covering core OOP design principles.
I have to give a recommendation to http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124
E-commerce is where it's at my man. E-commerce is straight forward. It's a store where you buy stuff. Real simple. However, the backend architecture is a bit more involved. You have to handle things like Databases, Queues, Cacheing, Error Logging, Load balancing, etc. If you want to be a mid-level back end dev you really need to understand the basics of Service-Oriented Architecture (SOA). You should also be familiar with CI/CD Pipelines and docker containers. Try looking into some open source e-commerce platforms:
https://codinginfinite.com/best-dotnet-core-e-commerce-open-source-platforms/
https://github.com/dotnet-architecture/eShopOnContainers
Also you need a strong understanding of Object Oriented Programming (OOP). So you'll need to understand S.O.L.I.D principles very well. Of the SOLID principles, you should focus heavily on the 'D' which stands for Dependency Inversion.
Lastly, in any decent back-end interview, they'll ask you about design patterns. I'd recommend "Head First Design Patterns" (https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/ref=sr_1_1?crid=3JOAGN3VIZZ8P&keywords=head+first+design+patterns&qid=1574177751&sprefix=head+first%2Caps%2C187&sr=8-1 )
Hope that helps!
I'll quibble with the "easy to read" part. As a reference, to look up one individual pattern and learn how to use it, I agree with you. As a cover-to-cover book to learn why patterns are important and how they relate to each other, I prefer Head's Up Design Patterns. I find it much more readable (source: I read it cover to cover, after having had the GoF book on my self for years and only reading bits and pieces).
My suggestion to anyone interested in design patterns is to read the Head's Up book, then have the GoF as a reference.
... none of which helps OP for his upcoming interview. :)
In addition to Code Complete 2, which, while very dense, is a compendium of wonderful coding knowledge... I recommend Clean Code by Robert C. Martin.
One of the best books on concurrency that I've ever read is definitely Java Concurrency In Practice it's (obviously) written with Java in mind, but most of the concepts map rather easily to constructs in other languages as well.
The standard for design patterns is still probably Design Patterns (colloquially "Gang of Four")... but I've heard good things about Head First Design Patterns as well, despite the really stupid cover.
I wouldn't say too early for having a good high-level overview of best practices.
It's always good to have a solid theoretical/philosophical understanding before diving into the specifics.
I'll put my vote down for Site Reliability Engineering as a good reference for high level ideas and less on the low level details.
I've posted this before but I'll repost it here:
Now in terms of the question that you ask in the title - this is what I recommend:
Job Interview Prep
Junior Software Engineer Reading List
Read This First
Fundementals
Understanding Professional Software Environments
Mentality
History
Mid Level Software Engineer Reading List
Read This First
Fundementals
Software Design
Software Engineering Skill Sets
Databases
User Experience
Mentality
History
Specialist Skills
In spite of the fact that many of these won't apply to your specific job I still recommend reading them for the insight, they'll give you into programming language and technology design.
I'd recommend Head First Design Patterns over the original GoF book because its way less dry.
The usual advice is "get out and program!" and that works, but it can be very tricky coming up with something to write that's also satisfying. The idea is that you learn best by doing, and that many topics in programming can't really be learned without doing. All that stuff is true and I'm not denying that at all, but some of us need more. We need something juicier than spending hours configuring a UI for a project we couldn't care less about. It shouldn't be an exercise in masochism.
I guess what I'm saying is that there are a lot of ways to learn to write code and books are great if you can really sink your teeth into them (a lot of people can't). Code Complete is a great book on the practice of programming. You also say that you "get" OO pretty well, but it might open your eyes to read up on design patterns (e.g., Head First Design Patterns). You have a long way to go before you really get it
In addition to those, you could delve deeper into your languages of choice. There's no way around JavaScript if you're a web programmer, and a book like JavaScript: The Good Parts is pretty enlightening if you've got some experience in JavaScript already. It's a pretty interesting and unusual language.
But sometimes programming is about building gumption, so instead of just being practical, try to figure out what you like about computers and keep going deeper into it. If you have an interest in computer science and not in just building apps, then something like Structure and Interpretation of Computer Programs could instill in you an enthusiasm for computers that trickles down to everything else you do. If you're more interested in web design, there are probably similarly interesting books on artistic design principles.
I think what I'm ultimately saying is that you should find what you enjoy doing and just go deeper down the rabbit hole, getting your hands dirty when it's appropriate and interesting.
It sounds like design patterns might be useful: http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124
Also, like the other commenters have said, you are mainly breaking up your program into smaller subprograms. However, it is really difficult to decide how exactly to break up your program. This is an entirely separate concern from things like algorithms and requires a different type of thinking. Design patterns, if you use them correctly, save time because you don't have to think up a new solution for every problem. They also make it easier for other people to understand your code, force separation of concerns, and make your program more extensible and modular.
If you look in the sidebar, you'll notice a few other subreddits that might be better for this question, like /r/askcomputerscience and /r/cscareerquestions.
I'm learning, like you, and from my experience the answers you'll receive will generally be to learn one language intimately, and to learn data structures and algorithms to the point where you can explain them in an interview and be ready to cobble together an implementation in code (whiteboard or on a computer). Also, design patterns. You'll see recommendations for CLRS and Head First Design Patterns.
Don't forget to check the sidebars and FAQs for each of these subreddits. Your answers are likely to already be there.
This?
http://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124
You sound exactly like me 10 months ago. I also took the plunge, moving from PHP/MySQL to C#/.NET. Keep in mind that I am not a .NET veteran, but I have gone from knowing nothing to developing all of my sites in it in just under 10 months.
The Shattering. There's a pretty good storyline about both Magni and Anduin as well, and how Moira came to have a seat in Ironforge. It really does fill in a LOT of what happened between wrath and cata. If you care about the storyline of wow, I'd dare say it's essential.
http://www.amazon.com/gp/aw/d/1439172749/ref=mp_s_a_1?qid=1321816538&amp;sr=8-1
edit: it's listed as hardcover, paperback, and ebook format, if anyone is wondering. I was just posting from my phone and grabbed the first link I came across.
Site Reliability Engineering: How Google Runs Production Systems
"Source code fuzzers". Wow. Unless you're fuzzing a compiler/interpreter, it doesn't make any sense at all. Really, you should start by finding in Google about the subject.
In any case, I recommend you to read the book "The art of software security assessment" [1] and a Bug Hunter's Diary[2].
[1] http://www.amazon.com/The-Software-Security-Assessment-Vulnerabilities/dp/0321444426
[2] http://www.amazon.com/Bug-Hunters-Diary-Software-Security/dp/1593273851
https://www.amazon.com/Algorithms-Algorithms-4-Robert-Sedgewick-ebook-dp-B004P8J1NA
This book is excellent, but it can be a little dense for beginners. I personally recommend: http://www.amazon.com/gp/product/B004P8J1NA/ref=oh_aui_d_detailpage_o04_?ie=UTF8&amp;psc=1
i used this book for my first comparch course, written by the guys who pioneered RISC and MIPS
goes over just about everything for the basics of how computer processors work, you can find a pdf online pretty easily
Do you understand a current ISA? This will become clearer once you do.
MIPS or RISC-V are the recommended ones to start with.
https://smile.amazon.com/dp/0124077269/ref=cm_sw_em_r_mt_dp_U_kfG4Db0D3JR91
https://smile.amazon.com/dp/0128122757/ref=cm_sw_em_r_mt_dp_U_hfG4DbCTTF7H3
Also, it is going to be much faster to implement a processor in an HDL than in Minecraft.
Signals and Systems, Oppenheim is a good introduction to System Theory, and Valkenburg's Analog Filter Design does well on filters (particularly active filters).
There isn't much good on passive (LC) filters still in print, though.
One gap in most references on filters is the specifics of elliptic filters. They lament the difficulty of elliptic functions and just cover using tables to design them. If you'd like some useful papers on elliptic filters though, let me know.
DSP is really useful in a wide variety of disciplines, especially if you end up becoming an embedded programmer. A lot of embedded code hooks into digital or analog sensors, and gleaning useful information from these sensors usually requires some amount of signal processing. Granted, it isn't always as complicated as what you'd learn in a DSP class, but it is really useful to know that stuff is available when you need it.
All this being said, I'm not going to lie to you, this material is not exactly intuitive, and can be very challenging to learn on your own. It is very math heavy, and there aren't very many good resources out there that I know of that can help with the learning curve.
Things that I used to help me get through the classes were:
I'm sorry to hear that the main prof is shitty. Maybe another thing to consider would be taking the class online from another university? This one looks pretty solid.
Good luck!
Data Structures & Algorithms is usually the second course after Programming 101. Here is a progression (with the books I'd use) I would recommend to get started:
Edit: If you're feeling adventurous then after those you should look at
College text books generally will go more in depth into them. They usually also provide proof of correctness as well as Big O and theta analysis.
Algorithms 4th ed is my favorite, the code is in Java but its text and illustrations are fantastic.
I really like /u/razeal113 's comment. That's a good algorithm for finding a good algorithm. Starting out with brute force isn't necessarily bad, as it at least gives you a jumping board to start optimizing. The only thing I would add is to increase your knowledge and toolbelt. You can gain a lot of inspiration and learn "how to think" by learning, analyzing, applying, and modifying all the awesome algorithms already out there. Here are some resources:
MOOCs.
Online challenges. There is a pretty good list at 14 Coding Challenges to Help Train Your Brain. From that list, I most liked:
Books.
Design Patterns. This is personal opinion, and I'm sure many would disagree, but for me, design patterns were the yin to algorithms' yang.
---
I think programming comes down to understanding data structures and how to manipulate them (algorithms). Linus Torvalds had it right when he said:
> Bad programmers worry about the code. Good programmers worry about data structures and their relationships.
One quick way would be to look up the algorithms courses offered by Stanford, MIT, etc and see what book the syllabus recommends. Some are offered as an MOOC as well (edX, Coursera, Khan, etc).
Also, you can check out these classic texts:
The Head First series is quite light and fun to read/work through. I'd suggest
https://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=pd_sim_14_5?ie=UTF8&amp;psc=1&amp;refRID=7QHH9XZJAXDWPFKR32BP
followed by
https://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1472716617&amp;sr=1-1
Honestly, not too sure if the first book is that great, as I haven't read it, but the look inside view looks quite good and the reviews aren't too bad. Maybe there are alternatives.
The second book I have read and would highly recommend. You need some basic beginner knowledge about objects and stuff first, though.
Edit: Also if you haven't done it yet, think about setting an IDE up for him (or let him do it himself). Nothing discourages more than having to mess with line numbers in compiler output logs, or get frustrated because you run the wrong class files and so on.
For the design elements, I definitely recommond Head First Design Patterns
It's a simple to follow book that does a good job of teaching you the patters and principles of OO design
When you start building a large piece of software, it's easy to get to the point where you think "Well this is starting to suck. I wish I had started building it like this instead." Those hard-earned lessons are design patterns. If you use the right one, the code you have in the later parts of the project will be easy to scale, easy to adapt to new requirements, and generally painless compared to how it would be without careful planning. Design patterns exist because the same problems tend to pop up repeatedly, so it's worth learning about them (before you need them).
It's difficult to give a general example because design patterns typically serve to solve involved technical problems you don't encounter until deep in a project. However, if you're looking for a good place to start I recommend checking out the Decorator Pattern. It's relatively easy to understand if you're coming from an OOP background. If you really want to learn them, I recommend checking out Head First's book. There are other good sources explaining them, but a lot of them tend to hurt your brain.
For design patterns, this book helped me a lot when I was fresh. https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
Don't be fooled by the cover or the content, it is quirky on purpose to help make you remember it.
I'd recognize that simuduck reference anywhere. it's Head First Design Patterns. We used this book in a class.
You may have to look up some of the terms in my reply and I apologize but, hey, you'll learn something.
I recommend Python, for the simple reason that Python manages to integrate several paradigms in one programming language (imperative, object-oriented, and functional) and a lot of what you learn with Python will carry over into other languages if you learn it deeply enough. E.g. Python has metaclasses which I believe were originally implemented in an older language called Smalltalk and so when I went over to experiment with Smalltalk (I like the Pharo implementation), it was no sweat understanding the idea of metaclasses.
Python also prepares you to read the kind of pseudocode you'll see on Wikipedia and in a lot of textbooks because Python reads a lot like pseudocode; it is an eminently readable language and actually enforces formatting conventions for clarity.
And should you decide to do a big advanced project, there are very frequently well-developed libraries available immediately available for your purposes, which is not an advantage you will get with some of the more obscure / less-used languages mentioned here.
For example, need to do machine learning? No problem! There's PyBrain.
Need to study complex graphs? No problem! There's NetworkX. (If you live in the United States, it's your taxpayer dollars at work, so enjoy.)
Need to do genetic algorithms? No problem! There's PyEvolve.
There's even a package for proving theorems in logic, FLiP.
Ruby comes recommended for similar reasons and has a purer object-oriented basis but (in my experience) fewer good libraries.
I have to disagree with several recommendations here: Lisp has been recommended in several posts and I have doubts about how much of a better or effective programmer it makes you; the evidence for such a claim is unclear and pretty much all anecdotal. And a lot of it is based on stereotypes about marginally competent enterprise Java programmer-types. Now that a number of programming languages have taken Lisp innovations like garbage collection and lexical closure to heart, there's not that much of an advantage anymore in Lisp. (IMO.) More to the point, I find that neither any implementation of Common Lisp nor Scheme enjoy quite the same support as Python.
For instance, even though Lisp has a reputation for being used widely in artificial intelligence, the AI libraries I can find for Common Lisp are relatively underdeveloped compared to those you can find for Python. For instance, in the case of soft computing methods in AI (which IMO are far more promising than logic-based approaches), between PyBrain and PyML you've got neural networks, SVM, reinforcement learning and more whereas I could only find fledgling projects like cl-machine-learning for Lisp, which apparently hasn't been worked on since 2009. (The Lisp community is notorious for not finishing projects once started.)
If you must use Scheme, I highly recommend Racket because it appears to be the most full-featured Scheme. (That's a major issue with Scheme: the standard specifies very very little and so the differing implementations tend to be kind of incompatible. One says that Scheme suffers from horrible "balkanization".)
Logo was mentioned, too. The NetLogo implementation is good for fast agent-based programming and a few other things (I found it highly useful for writing a Kohonen network implementation because of its inherently spatial character) but Logo as a language is not that great.
Prolog IMO is fucking terrible. Using it is like pulling your own teeth.
Pure functional programming languages like Haskell are kind of wanky as well. It's usually rather difficult to do anything useful with them because they disallow side effects completely but on the other hand, since you're interested in logic and computation, you'll get a lot of exposure to theoretical computer science ideas through these kinds of languages.
Bottom line is with Python you'll probably get more work done faster and have more fun that way too. And that's what counts.
One last note: I don't like SICP. Go on Amazon and look at some of the negative reviews to see what I mean. I can't exactly say what's a good intro to computer science because I'm well past that point now but this guy appears to come warmly recommended:
http://www.amazon.com/Python-Programming-Introduction-Computer-Science/dp/1887902996
And when you're a little more advanced, and want to dive into data structure and algorithms, the Segdewick "Algorithms" book is excellent, even if it uses Java for all the code:
http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X
The Princeton / Coursera algorithms course. It is great. You can find lectures (since the first course finished recently, and the second course is halfway done) here (you need to change the number at the very end. I think it starts at 10).
There is a book that's relatively cheap: http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X
And there's a booksite: http://algs4.cs.princeton.edu/home/
This course is done entirely in Java.
Algorithms by Robert Sedgewick
Good book with the code written in Java
Algorithms, 4th Edition and the companion Coursera Course are great if you are already familiar with a mainstream language.
I own Algorithms (4th Edition) . It's very well explained and uses Java as a base although it's easily readable if you are proficient with any other languages.
I agree with the Amazon review. Unless you need for a class, or learn an advanced topic not available in other places, I wouldn't touch this book ever. There are much easier algorithms books to read such as https://www.amazon.com/gp/product/032157351X/ This book isn't introductory at all as mentioned on Quora by multiple people https://www.quora.com/What-are-the-best-books-on-algorithms-and-data-structures
And if you've bought this for algorithms interviews preparation, it's better to buy cracking the code interview or similar which has explicit instructions for interview questions.
One more thing to add to the review was the algorithms are written in pseudocode, array indices start with 1 instead of 0, some lines refer to other pages in the book so you can never read a code inside this book sanely.
For anyone looking, the physical copy has also dropped on Amazon recently down to $50.
http://amzn.com/032157351X
No. And every fucking article about DDD in some php Framework should be hanged over running water then burnt and theirs ashes spread around the solar system.
Frameworks are just details in DDD. Your app may even be just a detail. What is your company making? What is your Core Domain on which you should assign your top people and resources? What is on the periphery and can be using software from outside?
DDD is more a way to organize your company and decide what to focus on. The architecture you get should come from analysing your domains, your contexts and change when your common knowledge about those get better.
Instead of reading these kind of blogs and applying cargo-cult php DDD read the red book.
The few comments in here aren't explaining WHY the interviewer said "very 90s". Obviously, "very 90s" is over-exaggerated... "very 2000s" is a bit more accurate.
What you've got is a "typical" layered architecture, which is considered a bit out-dated these days. There's a couple major reasons people move away from that architecture now.
For a quick look at an alternative project structure, you can check out Onion Architecture, which moves business logic to the application core on CodeProject (this is similar to ports & adapters)
For more in-depth, look into Domain Driven Design (DDD). Many an architect, including myself, would suggest Eric Evans' book on the topic.
For a more recent DDD book, see Vaughn Vernon's Implementing Domain Driven Design.
Read Implementing Domain-Driven Design . Customers and orders are in different bounded contexts, i.e. a customer object should not load all associated orders and vice versa.
Analog Circuit Design, 4 volume set D. Feucht
Analysis and Design of Analog Integrated Circuits P. Gray and R. Meyer
Analysis and Design of Digital Integrated Circuis Hodges and Jackson
Audio Power Amplifier Design Handbook D. Self
Optimizing Op Amp Performance J. Graeme
You could probably do a lot worse than A System Engineer's Guide to Host Configuration and Maintenance Using Cfengine by Mark Burgess (author of CFEngine and several system administration textbooks) and Aeleen Frisch (author of O'Reilly's Essential System Administration).
It's part of the USENIX short topics booklets. It's relatively short, cheap, and useful.
I say this all the time, but: Who would have thought that in the 2012, the greatest OS war of our day would still be BSD vs SystemV (iOS vs. Android)?
Generally, a focus in Windows is going to take you into corporate IT, building internally-oriented tools to support organizations. Here you'll want to learn bout VMWare, the full Microsoft stack, and look closely at tools designed for Enterprise support. There's less demand in this arena for nix, but also less chance to make a real impact on the world. Sure, there's something to be said for helping maintain the compute clusters inside of banks, or using Altiris or similar tools to manage hundreds of desktops for gigantic offices. I've done this myself, but I didn't have very much fun.
For my money, where you want to be is in web operations, building the systems that drive popular websites. Think about Instagram, Etsy, Netflix, companies that move enormous amounts of data around on the cheap, with relatively tiny staff. Read the blogs by the infrastructure team behind Etsy, and you'll realize quickly that these guys are geniuses.
Here you'll want to learn about how to interact programmatically with cloud compute providers, such as Amazon AWS, Rackspace Cloud, and the OpenStack providers that are starting to pop up, like HP. (A cloud provider is generally not just virtualization, but virtualization coupled with an API. It may sound small but it's a big difference!)
Here's some reading: If you want to learn a lot about nix operating systems, check out The Armadillo Book and The Practice of System and Network Administration.
If you're interested in learning web operations-oriented sysadmin, which is a VERY interesting place to be, also check out The Art of Scalability -- well, the first 2/3 anyway -- and the followup book, 50 Scalability Rules.
And especially, especially read and understand this, because there won't be many web-oriented companies still in business by 2014 that don't follow this process: Continuous Delivery.
Good luck! You picked a GREAT time to get started in the industry. The 00's were pretty boring by comparison. :)
EDIT: I KAN SPEEL
Essential System Administration - Good for any BSD; a classic
http://www.amazon.com/Essential-System-Administration-Third-Frisch/dp/0596003439/ref=sr_1_1?ie=UTF8&amp;s=books&amp;qid=1269300892&amp;sr=8-1
Not specific to Java, but make yourself familiar with Design Patterns. This book is a bit more approachable, the GoF version is a bit dry, but good.
This is usually one of the first things I give to new programmers where I work.
What you might want to do is pick up a book on design patterns. I am not aware of an good ones specifically aimed, at python though.
Learning the mechanics of doing OOP in python really isn't that hard. Learning how design your objects is the tricky bit. A book on design patterns basically is just a cookbook of things that work. It is about giving you practical examples of when you would use OOP.
Here are a couple books I have on the subject, and have found useful. Reading about design patterns was basically what let me actually understand the point of OOP.
So kudos to you for wanting to create more manageable code. I will take a look at your class when I get some time and give you some ideas, but for now I recommend this book that helped me immensely: Head First Design Patterns: A Brain-Friendly Guide. It is a fun read and goes over some of the most important patterns in OOP. I had to read each chapter a few times and practice coding solutions for the knowledge to sink in, but what you will learn is amazing. I was able to apply concepts to one of my games when using for instance the Strategy Pattern to swap out flying behaviors super easy and separate code that will change from code that will not change. I will be posting tutorials on this subject in the future at my new Unity Game Dev site: https://www.theunitygamedev.com
You can take a look at the book on Amazon here: https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
I would highly recommend Head First Design Patterns. If there's actually a bookstore near you you can probably just find a copy there and skim it to get what you need for now.
Design Patterns are typically generic, not specific to any particular language.
Nope.
I've been a professional programmer for 20 years and I still don't formally know design patterns.
What I mean by "formally" is that I naturally use more basic patterns without even realising it.
However, recently I've moved into software architecture for my company, and am finding that there are more and more reasons to learn and understand patterns, as they help design complex systems.
Definitely focus on programming first. Patterns will come.
Also, a tip - people will always recommend the Gang Of Four book (https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612) for design patterns. And it is the gold standard book for Design Patterns. However, in my opinion, it is an incredibly 'dry' read.
Head First Design Patterns (https://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1466670651&amp;sr=1-1&amp;keywords=head+first+design+patterns) is a much better introduction to design patterns for most people.
You are welcome :).
This is one of the best book to learn programming http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871. It's freely available and the class at MIT which uses this is here http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/
Peter Norvig's advice http://norvig.com/21-days.html
Programming Pearls : http://www.cs.bell-labs.com/cm/cs/pearls/
At https://www.codeeval.com you can solve questions and get interview calls.
You may also want to brush up your design skills as few interviewers might ask those kind of questions. http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124 might be a good place to start.
I think http://www.geeksforgeeks.org is a good place to look for nicely explained solutions and you can find almost all the questions ever asked in a software engineering interview at careercup.com
Agreed. There are plenty of resources out there that will help you understand design patterns. If you're new to the concept, I would recommend Head First: Design Patterns, it might be based on Java, but the examples are simple to understand and can mostly apply to PHP as well. When you feel like you've grasped the basic concepts of design patterns, you can move on to more advanced texts, like Martin Fowler's Patterns of Enterprise Design - this is a great reference for a lot of the more common patterns. There is also Refactoring: Improving the Design of Existing Code. These are great investments that will help you with any project you work on, and will help you if you decide to use a framework like Zend which uses design patterns very heavily.
The book Clean Code will help with improving your code in general.
Head First Design Patterns is great! But in Java. The patterns still apply to Python though.
Here are patterns in Python https://github.com/faif/python-patterns
Have you ever considered reading the SICP book from MIT? You could also try an algorithms book, and brush up on your design patterns.
Unfortunately, there's no real fast-track.
That being said, focus on design patterns and algorithms. Understanding and putting design patterns into use is absolutely your best starting place. Knowing and learning new algorithms gets your brain thinking in the right way about any problem you're trying to solve. These two topics on their own can be really pretty dry and boring, but there's only two ways to learn them. The slow way, by trial and error, by experience (which you've been doing). And the boring way, that's slightly faster, study.
Introduction to algorithms is really good, but dry.
Head First: Design Patterns If you've never used a head first book, they're really well done IMO. Just commit yourself to a chapter a day once a week or something, force yourself through it, and you'll learn tons.
Another pro tip, re-write your existing code. When you realize you should've done something differently, fix it. Any time you find yourself copy pasting code, or thinking to yourself, damn, I should've made an abstract class, or a factory, or ... whatever it is, go through the process. In the end, it always comes down to doing. Learning this stuff only comes from doing.
While this is an extremely good book, it is old fashioned and uses examples that are difficult to understand if you are working with modern web technology.
If you are programming Java, Head First Design Patterns is a better choice. It contains the same patterns, but it is much easier to understand.
I learned Java in the late 1990s from the first edition of Learning Java and also some of the official online tutorials. I just fooled around with it a short bit. I relearned Java some years later from Head First Design Patterns and Effective Java. The Patterns and Effective books really help you design your classes. Ps: I know nothing about Android programming.
What books can help you expand your knowledge of design patterns?
The second one (GoF book) is the defacto standard, but unfortunately, it's also a cure for insomnia. The first one is much more entertaining.
I'd very much agree with this, but not having read any others I can't recommend them. I have heard that Head First Design Patterns is good.
Hey there! I personally love patterns. I think there are one of the single best things you can learn as a programmer. So here are some resources I have used and was successful with.
Design Patterns (Gamma, Helm, Johnson, Vlissides)[aka the Gang of Four] is THE Design Patterns book, but it's a little dry and I don't think it talks about MVC that much. I've gotten about 1/3 of the way through it twice, I just keep getting distracted and forget about it.
Head First Design Patterns has gotten a lot of good reviews and I've head good things about the Head First series of books, but I haven't read any of them myself.
I'm not sure about any online tutorials, but I'm sure they exist.
I taught myself a little about Design Patterns and MVC, but I'm sure I understand them just enough to be dangerous. I'm going to be taking a class this Fall that should talk about Design Patterns more.
I would recommend you reading O'Reilly's Head First: Design Patterns It is oriented for Java, but the patterns are the same in most OO languages. I compiled all the examples in C++ and all was great.
The book essentially teaches you how to write code that is easy to modify later on.
I agree about design patterns. They keep you from re-inventing the wheel. I find Head First Design Patterns easier to approach than the gang of four book.
OOP won't make sense until you understand design patterns. IMO this is the best book you can find to start learning design patterns. It's for Java but you can apply the ideas on any modern language.
Read Head First design patterns and really understand what encapsulation means.
PHP The Right Way is good.
If you want something for SQL I strongly recommend SQL Antipatterns.
If you want something more abstract, Head First Design Patterns is good. It uses Java in its examples but it applies to PHP too.
Sure! This is a great desire to have.
Clean Code probably most closely deals with you're specific question. It's very readable, and uses Java for the examples. http://www.amazon.com/gp/aw/d/0132350882
But while you're looking for recourses along these lines, you might also take a look at the super thick, bit super good Code Complete: http://www.amazon.com/gp/aw/s/ref=is_s_ss_i_1_7?k=code+complete+2
Lastly, it also sounds like it might be time to start thinking about design patterns - these are ways to implement solutions to common problems in your code using well-established design principles. The "Gang of Four" book is the classic on the topic, but this one offers a more readable introduction I feel: http://www.amazon.com/gp/aw/d/0596007124/
(Sorry for lack of link formatting, I'm on mobile.)
I think the best way to learn is by doing, so I suggest doing a big project in Java. The Java documentation talks about object-oriented programming a lot and is a good read.
If you want something to read, this book looks a little kooky, but don't judge a book by its cover. It is probably one of the easier to read books on the subject, but still has a lot of good information
There are some SUPER valuable insights in the replies of this thread that took me YEARS of programming to fully understand. So you did yourself a great service asking this question here :)
&nbsp;
These insights are:
by u/cmd-t
> think in OOP in terms of passing messages from object to object. Every function call is actually sending a message to an object: a request for it to do something.
by u/saturnflyer
> Don't model the real world. Create the world you need.
by u/tom_dalling
> It's a common misconception that classes model real-world things. Classes model data, or behavior, or responsibilities.
&nbsp;
To answer your question, yes, OOP is hard to master. As a result, there are many books written on the subject. And for a complicated system, even senior developers will have trouble getting the design right on a first try.
&nbsp;
If you feel lost, it's not because you are not good at this. It's because the subject you are learning does require lots of time and practice.
IMHO, the best way to learn this is by actually working alongside with senior engineers in a real production project. So you can see some existing designs and also bounce ideas with other engineers.
While that might not be possible at the moment, you can
&nbsp;
Happy coding and I hope to see you posting more questions here! :D
Many game programming books start off at step 4 so you need to do 1-3 before you get into those books. Never get an old book for step 4, the game specific stuff gets out of date too fast. Anything that does 1-4 all at the same time probably isn't worth it.
It's never too early to familiarize yourself with best and current practices within the field.
I'm not sure what your financial situation is as a student, but I would start by locating and getting in contact with the IIBA or PMI local chapter closest to your home or university. It is an invaluable way to build your professional network, discuss the field, and listen to lectures and presentations built on real world experience.
There are also a number of websites which have useful information about the field (white papers, articles, etc.):
If you are inclined to purchase books, I've found the following very useful in my career:
I would say start with the free websites, immerse yourself in the culture/field and take in all you can. Participate in the r/BusinessAnalysis forum. Finally, network your butt off get a job and start your career.
If you have any other questions feel free to ask or PM me.
It's long but you could watch this. https://www.youtube.com/watch?v=P0iKFASurHk
Also if you want to read the books, here is the order in which you should.
[World of Warcraft: Dawn of the Aspects] (http://www.amazon.com/World-Warcraft-Richard-A-Knaak/dp/147676137X)
[Warcraft: War of the Ancients #1: The Well of Eternity] (http://www.amazon.com/Warcraft-War-Ancients-Well-Eternity/dp/0743471199)
[Warcraft: War of the Ancients #2: The Demon Soul] (http://www.amazon.com/Warcraft-War-Ancients-Demon-Soul/dp/0743471202)
[Warcraft: War of the Ancients #3: The Sundering] (http://www.amazon.com/Warcraft-War-Ancients-Sundering-Bk/dp/0743471210)
[World of Warcraft: Rise of the Horde] (http://www.amazon.com/World-Warcraft-Rise-Horde-No/dp/0743471385)
[Warcraft: The Last Guardian] (http://www.amazon.com/Last-Guardian-Warcraft-Book-No-3/dp/0671041517)
[World of Warcraft: Tide of Darkness] (http://www.amazon.com/Tide-Darkness-Warcraft-Aaron-Rosenberg/dp/1416539905)
[World of Warcraft: Beyond the Dark Portal] (http://www.amazon.com/Beyond-Dark-Portal-World-Warcraft/dp/1416550860)
[Warcraft: Day of the Dragon: Day of the Dragon] (http://www.amazon.com/Day-Dragon-WarCraft-Book-No-1/dp/0671041525)
[Warcraft: Lord of the Clans] (http://www.amazon.com/Lord-Clans-Warcraft-Book-2/dp/0743426908)
Warcraft: Of Blood and Honor
[World of Warcraft: Arthas: Rise of the Lich King] (http://www.amazon.com/Christie-Golden-World-Warcraft-Arthas/dp/B00320J28G)
[World of Warcraft: Cycle of Hatred: Cycle of Hatred] (http://www.amazon.com/Cycle-Hatred-World-Warcraft-Bk/dp/0743471369/)
[World of Warcraft: Night of the Dragon] (http://www.amazon.com/World-Warcraft-Richard-A-Knaak/dp/0743471377)
[World of Warcraft: Stormrage] (http://www.amazon.com/World-Warcraft-Stormrage-Richard-Knaak/dp/1439189463)
[World of Warcraft: The Shattering: Prelude to Cataclysm] (http://www.amazon.com/World-Warcraft-Shattering-Book-Cataclysm/dp/1439172749)
[World of Warcraft: Wolfheart] (http://www.amazon.com/World-Warcraft-Wolfheart-Richard-Knaak/dp/1451605765)
[World of Warcraft: Thrall: Twilight of the Aspects] (http://www.amazon.com/World-Warcraft-Thrall-Twilight-Aspects/dp/143919663X)
[World of Warcraft: Jaina Proudmoore: Tides of War] (http://www.amazon.com/World-Warcraft-Jaina-Proudmoore-Tides/dp/1451697910)
[World of Warcraft: Vol'jin: Shadows of the Horde] (http://www.amazon.com/World-Warcraft-Voljin-Shadows-Horde/dp/1476702977)
[World of Warcraft: War Crimes] (http://www.amazon.com/World-Warcraft-Crimes-Christie-Golden/dp/1451684487)
There's not a lot out there. A short story on the wow website about Baine Bloodhoof: http://us.battle.net/wow/en/game/lore/leader-story/baine-bloodhoof/1
I'm pretty sure that "The Shattering" book about the Cataclysm also talks about Cairne and Baine: http://www.amazon.com/World-Warcraft-Shattering-Book-Cataclysm/dp/1439172749
Although I have not read that book.
You can also check sites like Wowpedia: http://www.wowpedia.org/Tauren
Sysadmin, I've been doing Lead SysEng/DevOps/SRE for the past 4 years and literally have multiple written offers I'm trying to choose from right now.
I only started looking 3 weeks ago.
Learn multiple clouds(I've done the big 3 in prod and other ones for utils/tools/hobby/legacy systems), Kubernets/docker, Linux, distributed systems and ansible/puppet/chef
Read this:
https://www.amazon.com/Practice-Cloud-System-Administration-Practices/dp/032194318X/
and this:
https://www.amazon.com/Site-Reliability-Engineering-Production-Systems/dp/149192912X/
See if you can buy time for the internship offer, having multiple offers is always better :)
Is the internship paid?
If I were you I would look into the site reliability engineering book. The first few chapters address your question pretty well. The tl;dr version is don't guess. Get stakeholders (specifically management) to agree to a specific SLA target based on your needs and provide the funding necessary to hit those numbers.
Application Security:
Web Security:
Secure Systems
You can practice on open source projects. This is another book I liked:
http://www.amazon.com/Bug-Hunters-Diary-Software-Security/dp/1593273851/
A mix of black box testing, knowing what vulnerable code looks like and reverse engineering.
Because for some tasks you really do need to know whether a bucket sort or a quicksort is more appropriate. For some tasks, you really do need to know whether to use a Set or a List, and knowing the difference can occasionally save you from reinventing the wheel.
If you're looking for a great book to study that covers all these practical topics, check out Algorithms by Robert Sedgewick.
I learned mostly through reading textbooks in University, but not many of the books we were assigned stood out as being particularly great. Here's a few that I did enjoy:
To balance things out, I'll also give a list of books I thought were awful:
This question goes beyond the scope of a reddit post. Read a book like Code by Charles Petzold, or a textbook like Computer Organization and Design or Introduction to Computing Systems.
In the meantime you can look at things like datapaths which are controlled by microcode.
This question is usually answered over the course of a semester long class called "Computer Architecture" or "Computing Systems" or something like that, so don't expect to understand everything right away.
Copy pasting my response to a similar question:
Edited to have more resources and be easier to read.
It's hard to draw the line between "essential" and "recommended." That depends a lot on what you want to do. So, I will present a rough outline of core topics covered in the 4 year CS program at my university (UC Berkeley). This is not a strict order of topics, but prerequisites occur before topics that depend on them.
Intro CS
Topics include Environments/Scoping, abstraction, recursion, Object oriented vs functional programming models, strings, dictionaries, Interpreters. Taught in Python.
The class is based on the classic MIT text, "Structure and Interpretation of Computer Programs." Of course, that book is from 1984 and uses Scheme, which many people don't want to learn due to its rarity in industry. We shifted recently to reading materials based on SICP, but presented in python. I believe this is the reading used now. This course is almost entirely posted online. The course page is visible to public, and has the readings, discussion slides / questions and solutions, project specs, review slides, etc. You can find it here.
Data Structures and basic algorithms
DS: Arrays, Linked Lists, Trees (Binary search, B, Spaly, Red-Black), Hash Tables, Stacks/Queues, Heaps, Graphs. Algorithms: Search (Breadth first vs depth first), Sorting (Bubble, radix, bucket, merge, quick, selection, insert, etc), Dijkstra's and Kruskal's, Big-O analysis.
This class uses two books: "Head First Java" and "Data Structures and Algorithms in Java" (any edition except 2). The class doesn't presupposed knowledge in any language, so the first portion is covering Object Oriented principles and Java from a java book (doesn't really matter which), then moving to the core topics of data structures and algorithms. The course page has some absolutely fantastic notes -- I skim through these before every interview to review. You can also check out the projects and homeworks if you want to follow along. The course page is available here (note that it gets updated with new semesters, and links will be removed -- download them soon if you want to use them).
Machine Structures (Intro Architecture)
Warehouse scale computing (Hadoop Map-Reduce). C language, basics of assemblers/compilers/linkers, bit manipulation, number representation. Assembly Language (MIPS). CPU Structure, pipelining, threading, virtual memory paging systems. Caching / memory hierarchy. Optimization / Performance analysis, parallelism (Open MP), SIMD (SSE Intrinsics).
This class uses two books: "The C Programming Language" and "Computer Organization and Design". This class is taught primarily in C, so the first few weeks are spent as a crash course in C, along with a discussion/project using Map-Reduce. From there in jumps into Computer Organization and Design. I personally loved the projects I did in this class. As with above, the lecture slides, discussion notes, homeworks, labs, solutions, and projects are all available on an archived course page.
Discrete Math / Probability Theory
Logic, Proofs, Induction, Modular Arithmetic (RSA / Euclid's Algorithm). Polynomials over finite fields. Probability (expectation / variance) and it's applicability to hashing. Distributions, Probabilistic Inference. Graph Theory. Countability.
Time to step away from coding! This is a math class, plain and simple. As for book, well, we really didn't have one. The class is based on a series of "Notes" developed for the class. When taken as a whole, these notes serve as the official textbook. The notes, homeworks, etc are here.
Efficient Algorithms and Intractable Problems
Designing and analyzing algorithms. Lower bounds. Divide and Conquer problems. Search problems. Graph problems. Greedy algorithms. Linear and Dynamic programming. NP-Completeness. Parallel algorithms.
The Efficient Algorithms class stopped posting all of the resources online, but an archived version from 2009 has homeworks, reading lists, and solutions. This is the book used.
Operating Systems and System Programming
Concurrency and Synchronization. Memory and Caching. Scheduling and Queuing theory. Filesystems and databases. Security. Networking.
The Operating Systems class uses this book, and all of the lectures and materials are archived here (Spring 2013).
Math
Those are the core classes, not including about 4 (minimum) required technical upper division electives to graduate with a B.A. in CS. The math required is:
Those are the core classes you can expect any graduate from my university to have taken, plus 4 CS electives related to their interests. If you could tell me more about your goals, I might be able to refine it more.
Patterson and Hennessy's textbooks, Computer Architecture and Computer Organization and Design are pretty much the standard textbook used in every computer architecture class, everywhere.
> We use vivado in school and they teach verilog. My impression is that VHDL is more of an industry standard, but I'm still a student so don't quote me on that. The way my university introduced digital logic was by having us start at logic gate level then use those modules to make state machines and last semester we made a MIPS processor.
>
Vivado (web pack should be free)
https://www.xilinx.com/products/design-tools/vivado.html
> Here is the book we used for the processor
https://www.amazon.com/Computer-Organization-Design-Fifth-Architecture/dp/0124077269
~ /u/laneLazerBeamz
Are you familiar with logic design (multiplexers, decoders, registers, logic gates, etc)? Computer Organization and Design covers a lot of it and is relatively easy to read. But having some background in digital logic will help a lot.
Buy this textbook & read it
https://www.amazon.ca/Signals-Systems-2nd-Alan-Oppenheim/dp/0138147574/ref=sr_1_1?keywords=oppenheim+signals+and+system&amp;qid=1559266548&amp;s=books&amp;sr=1-1
also a useful quick reference : http://www.dspguide.com/
Awesome list, thanks for sharing. This so very useful to me as I'm currently in an apprenticeship to become a software developer and am working through this textbook Data Structures and Algorithms and could use all the other helpful links I can get!
Might be biased, but I'm a big fan of Jeff Erickson's Algorithm Notes, which I think are better than a lot of textbooks.
If you really want a book, CLR Algorithms and The Art of Computer Programming both get recommended a lot, with good reason.
If you're interested in computational theory, the New Turing Omnibus and Spiser's Theory of Computation are two good choices.
Finally, I'd check out Hacker's Delight. It's a lot more on the electrical/computer engineering side of things, which might interest you, and it's very detailed while still being quite excellent.
The goto theory book by Sipser.
Excellent for C programming.
Programming in general.
My favourite.
You can probably find all of these at a library.
I have heard this is a great book. It also has practical exercises to sink everything in.
A better learning environment (but still low level) would be Elements of Computing Systems: Programming a Computer from First Principles. Almost every computer created in Minecraft was built based on the computer designed for this book. Minceraft provided the environment, but the book provided the knowledge.
This is the opposite of an ELIF answer but this book will tell you in detail. It takes you through building a computer from the ground up, starting with hooking logic gates together, through building your own OS and compiler from scratch. It does everything in the simplest possible way, so it all fits in one reasonably-short book.
It gives you a simulator so you can run your "home-built" computer without having to physically build it.
I heard good things about The Elements of Computing Systems
http://www.idc.ac.il/tecs/
http://news.ycombinator.com/item?id=1608976
http://www.amazon.com/Elements-Computing-Systems-Building-Principles/dp/026214087X
Code: The Hidden Language of Computer Hardware and Software,The Elements of Computing Systems and Inside the Machine were recommended on Hacker News.
I have the last one, I will re-read it over Easter holidays...
Python, then Java, then C, then Assembly. But first (and this is the most important advice you're going to get from this thread), go through this book from cover to cover, including the exercises.
Also, congrats on choosing the best field in the world.
I have started reading this book and so far I am enjoying it
Domain-Driven Design: Tackling Complexity in the Heart of Software https://www.amazon.com/dp/0321125215/ref=cm_sw_r_cp_apa_i_R60tDb2Y19V4X
It came recommended to me from a few different sources including Reddit.
Do yourself a huge favor and just read this.
Well, any logic which doesn't encode business rules is, by definition, not business logic. So, for example, most or all of the logic within your infrastructure layer would not be business logic. But I suspect what you're really asking is "what sort of non-business logic belongs in a VO?" The answer to that is simply: any logic which goes hand-in-hand with the value being represented, and is side-effect free. One of the examples Eric Evans gives is that of a
PaintVO which has a methodmixIn(Paint $otherPaint): Paintthat encapsulates the logic of mixing one paint into another, and produces a new VO.Domain-Driven Design: Tackling Complexity in the Heart of Software by Eric Evans
Domain Driven Design by Eric Evans.
There's a whole book dedicated to this topic called Domain Driven Design.
A customer purchases tickets, not train services. And a train service has customers, but the train has passengers. You should keep the concepts separate. How about introducing a third concept - a ticket?
A customer has many tickets for past journeys. The ticket doesn't need to maintain a reference to the train service, but the train service should be able to identify tickets it issued. And the ticket doesn't need to keep a reference to the customer. Nice clean separation between two indpedent concepts, or Bounded Contexts as it is called in DDD.
We evolved an app architecture similar to the one he presents. However, it is also proprietary. It is truly a joy to work with though :)
I would say the key characteristics are roughly:
The following books would be good suggestions irrespective of the language you're developing in:
Patterns of Enterprise Application Architecture was certainly an eye-opener on first read-through, and remains a much-thumbed reference.
Domain-Driven Design is of a similar vein & quality.
Refactoring - another fantastic Martin Fowler book.
I'M REALLY SORRY YOU'RE HAVING A HARD TIME.
NOT SAYING YOU HAVEN'T TRIED, I COMPLETELY BELIEVE YOU. BUT IF YOU BRANCH AWAY FROM THE CODE-BOOTCAMP/WEB-DEV ARENA THERE IS CURRENTLY A MASSIVE SHORTAGE OF PEOPLE THAT CAN ACTUALLY PROGRAM. COMPANIES LIKE NIKE FLY IN DEVELOPERS FROM ALL OVER THE COUNTRY STRAIGHT OUT OF COLLEGE.
WE INTERVIEW SO. MANY. FUCKING. PEOPLE. THAT DON'T KNOW THE ABSOLUTE BASICS.
PUSH THE "WRITING SOFTWARE IN PYTHON" ASPECTS OF YOUR PAST EXPERIENCE AND DOWNPLAY ANY HTML/CSS/JAVASCRIPT STUFF. SPEND A MONTH LEARNING THE BASICS OF JAVA. THEN SIGN UP FOR LEETCODE AND CODERBYTE (FREE VERSIONS) AND SOLVE A PROBLEM A DAY FROM EACH, FOR 30 DAYS. IF YOU DON'T KNOW HOW, GOOGLE IT UNTIL YOU DO. LEARN THE ABSOLUTE BASICS OF ALGORITHMS, EFFICIENCY, AND RUNTIME COMPLEXITY THROUGH COURSERA, OR A BOOK LIKE THIS, AND ADVERTISE THE SHIT OUT OF IT ON YOUR RESUME. THIS IS WHAT THEY'RE LOOKING FOR.
SHOW UP LOOKING LIKE A NORMAL HUMAN, YOU'LL BE ABLE TO ANSWER QUESTIONS ABOUT THE EFFICIENCY OF CERTAIN ALGORITHMS OVER ANOTHER AND WHEN THEY ASK, YOU WILL SOLVE A WHITEBOARD PROBLEM THAT WILL LIKELY BE A WORD-FOR-WORD COPY OF ONE OF THE PRACTICE PROBLEMS YOU SOLVED ON LEETCODE. DO THIS AND I GUARANTEE THEY WILL JUMP YOUR BONES TO GET YOU ON THE TEAM. THAT'S WHERE THE MONEY AND MARKET IS RIGHT NOW, AND THERE ISN'T ENOUGH PEOPLE TO FILL IT.
You can't go wrong with Sedgewick's Algorithms. I prefer its approach to Cormen's book.
http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X/ref=sr_1_1?ie=UTF8&amp;qid=1408422212&amp;sr=8-1&amp;keywords=algorithms
The feedback about "jargon for development" can be solved by going through some books cover to cover, making sure you understand the theory, and implementing the exercises. I understand that feedback to mean that the person who gave the feedback believes there is too high a chance you will inflict damage on the codebase by making decisions not grounded in solid theory.
Examples of titles that are classics and widely known:
Algorithms (4th Edition): https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X (there is an accompanying coursera course).
Code Complete: https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1469249272&amp;sr=1-1&amp;keywords=code+complete
Clean Code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1469249283&amp;sr=1-1&amp;keywords=clean+code
Functional Programming in Scala: https://www.amazon.com/Functional-Programming-Scala-Paul-Chiusano/dp/1617290653/ref=sr_1_2?s=books&amp;ie=UTF8&amp;qid=1469249345&amp;sr=1-2&amp;keywords=scala
Learning Python: https://www.amazon.com/Learning-Python-5th-Mark-Lutz/dp/1449355730/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1469249357&amp;sr=1-1&amp;keywords=learning+python
Effective Java: https://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683/ref=sr_1_5?s=books&amp;ie=UTF8&amp;qid=1469249369&amp;sr=1-5&amp;keywords=java
Haskell Programming From First Principles: http://haskellbook.com/
I included multiple languages as well as language-agnostic ones. Functional programming is the near-to-medium term future of software engineering, and most languages converging towards that as they add functional features.
I don't think bootcamp is required. Learning how to learn is the most important thing. If you get into these books, lose track of time, and feel "aha! that's how these things that I previously thought were unrelated are actually the same thing!", and are able to keep it up for weeks, then that is a good sign that you can get to where you want to be.
Or "Computer Organization and Design, Fifth Edition: The Hardware/Software Interface"
http://www.amazon.com/Computer-Organization-Design-Fifth-Edition/dp/0124077269
Io non sono molto un tipo da libri, ma tra i miei preferiti avevo salvato :
>is book could have been useful also for C++ real-time programmers of course because i would include also HW information used in that field.. probably I'm asking too much now..
It wouldn't be. You misunderstand how that field of programming works. Differences can be HUGE and you would end up using at least something like https://www.amazon.com/Computer-Organization-Design-MIPS-Architecture/dp/0124077269.
Why? Because hardware used there can be fundamentally different than your typical computer. How much? Well... some CPUs don't support recursion. No, really. Do more than 2-3 recursive calls and CPU rans out of memory. You also end up using FPGAs and ASICs. To explain all that is way more than a book.
You seem to want a hypotethical book on "current PC hardware and it's performance". Which frankly is not in a form of a book but comes from visiting places like Guru3d and anandtech. Actual low level differences that WILL matter for a programmer are hidden in CPU specs sheets and to read that you need resources that target computer architectures and your problem domain specifically. Well, that and practice really - someone working in game engine development is likely to know graphics pipeline like the back of their hand and can easily talk about performance on several GPUs and pinpoint what makes one better than the other. But that came from experimenting and plenty of articles, not a singular resource. Too many different requirements really to create a single resource stating that "X is good for Y branch of programming but bad for Z".
I mean, even within desktop CPUs themselves. Would you rather have a 14 Core i9 9980XE or a 32 core Threadripper 2990WX? Answer is - it depends. One has far superior single threaded performance due to higher clock, the latter will eat it alive in heavily multithreaded and independent processes (2990WX has 32 cores but only 16 are connected to the rest of your computer, this can cause very visible delays so there are multithreaded scenarios when it will underperform). And in some cases you will find out that an 8-core 9900k is #1 in the world. It ALL depends on a specific application and it's profile.
You shouldn't worry so much about different programming languages. They all more or less work the same. I would recommend you learn how a computer works at a low level and work your way up. You could start here, then move on to this. This kind of knowledge makes a lot of things clearer.
Find it here on Amazon. It's actually a pretty good textbook and worth reading even if you're mostly a software developer.
Ahh gotcha. A more intuitive description might be that the Guassian is a neat way of "smoothing" your function. If you are looking at your function f at some time t, then the Gaussian just adds a little bit of the function at times close to t, say f(t+1) and f(t-1).
The mathematical description of applying this filter on your entire signal is called convolution, and the DFT provides ways of doing this quickly.
For reference, I learned from the book Signals and Systems
As a software developer the hardest part will probably be sharpening your mathematics skills. At my undergrad the CS kids only took up to Calculus II, which is really not enough math.
I started on DSP as a sophomore, teaching myself from this book. Even though I was able to implement a few filters successfully and understand the basics, I don't think it really clicked until I took a linear systems course.
All that being said, you can totally do it. But it won't be easy without the technical background - sure you use the tools we make, but honestly we hide most of the technical parts from the user anyway (the user doesn't know about or care about Butterworth vs Chebeshev filters). Put in the work to learn the mathematics. I recommend Oppenheim and Willsky if you don't have the linear systems background. Besides that, you really just need to show the company that you're a music lover, and it looks like for you that should be easy enough. PM me if you want more info.
Relax. There are plenty of good books, but most of them will actually be your course literature in university. You do not gain anything substantial by trying to go through that now. Instead make sure that CS is the right field for you at all. Figure out what studying CS is all about, realize that it will not be like taking programming classes for 4 years. Instead, like I said, work on basic programming skills. Lots of students go into CS without being able to program, and you'll have a much easier time if you have familiarity with practical concepts by then.
If you really want some classic books, though:
Data Structures and Algorithms. Aho, Ullman & Hopcroft
> I am pretty realistic
>I would like to become a computer programmer overnight.
L OMG L
That said, read something like this http://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237 . The language you choose is nearly irrelevant vs the concepts you'll need to apply.
Beyond the recommendation for information theory, the application of this mathematics to user interfaces is present in the field. (I'm not particularly familiar with the field, but I remember The Humane Interface discussing this application.)
My favorite book has always been The Humane Interface by Jef Raskin. A lot of the practical stuff he talks about (windows and buttons) was because he wrote this book from like a 1970's perspective, but he is a fucking genius.
Read his father's book.
The other major website on this subject is the Aggregate Magic Algorithms.
You can also find some interesting hacks at the Chess Programming site bitboards.
The magnificent book Hacker's Delight is the Knuth of bits. It's actually better than Knuth on this subject! (At the end of 50 pages of bitwise stuff in Volume 4, DEK basically says "read Hacker's Delight for the real deal.")
you want hacker's delight
Consider 'The Elements of Computing Systems' if you would like a grand tour of our current computer architecture. Start with logic gates and eventually build an operating system: http://www.amazon.com/Elements-Computing-Systems-Building-Principles/dp/026214087X
The book has got to be five out of five for a reason, right? Good luck!
Quick note about number 6: Those terms are a lot more intimidating than they sound. Some of them take a little while to really grok what they are and why they are useful but once you understand them they are extremely useful (and huge selling points for yourself as a developer).
About the interview: From what I've heard the questions they ask are different based on different backgrounds. They are less likely to ask software development methodology questions to a new graduate since that's not really in the realm of computer science.
I did get asked some questions regarding data structures and algorithms. The ones that I was asked, and I feel I did really well on, were more related to problem solving and software architecture. Think of it this way, if they hire you, in your day to day job having memorized how to traverse a graph isn't going to come up that often. Your day to day is going to consist of coming up with solutions to problems presented with you.
So when they ask a question like how to traverse a graph, they aren't looking for you to be able to spit out Dijkstra's algorithm exactly. Instead, they are looking to see how your brain works and what kind of solution you can come to by logically breaking down the steps to solve the problem.
They are looking for how you take a problem, break it down in pieces, and what your solution would look like.
Example: Implement a scale, that has two sides and lets you know based on the objects on the two sides, which side is heavier and by how much?
My answer to this question would be something like:
How do you store the set of items on each side of the scale internally in the scale class? Do you need to be able to remove items from the scale, and why would this affect how you store the items internally? Should the scale have a weight limit?
These are all great questions to ask. Think out loud, talk out loud. They want to see that when confronted with a problem you don't know the answer to, or don't know the best solution to that you don't freeze up but instead chunk it up and try to reason your way through it.
"Should the scale have a weight limit?" Asking the interviewer this question is a huge win in your favor. It shows that not only are you trying to solve the problem, but you're constantly thinking about issues that might have been overlooked in the initial assessment.
Back on number 6: I learned these by googling a fuckton. Watching a lot of videos, reading a lot of tutorials, and just asking a lot of questions.
Here's some resources I still have bookmarked from the last year/18 months. Some of them are for targeted for php, but the concepts are universal. But if any of these don't do it for you, google a bunch.
Solid: 1 2
Inversion of Control & Dependency Injection: 1 2 3 4
Domain Driven Design: This is actually a ton of concepts, and you don't necessarily need to learn them all at once. This book is the only software architecture book I've read cover to cover, its that good. If you can afford to, do buy it. Also another helpful link Intro to DDD.
Test Driven Development and UnitTesting: 1 2
Also I've found many of the top answers stackoverflow user tereško are great sources of wisdom regarding software development.
Interesting!
Looks to me that you can "feel" what good code looks like but you're not able to rationalise it enough for you to write it on your own.
Couple of suggestions:
When you see elegant code, ask yourself: why is it elegant? Is it because is simple? Easy to understand? Try to recognise the desired attributes so you can try to reproduce on your code.
Try to write really short classes/methods that have only one responsibility. For more about this, search for Single Responsibility Principle.
How familiar are you with unit testing and TDD? It should help you a lot to write better designed code.
Some other resources:
Have you ever heard of the open/closed principle? Or the single responsibility principle? Or Liskov substitution principle? All three are being violated. It drastically reduces the maintainability and extensibility of your code. I can't swap serializers easily, i can't tweak or extend them without touching that huge class and it's definitely not the responsibility of that class to know how to serialize A, B, C, D, E and the whole alphabet.
I highly recommend some literature on the subject if you're curious about it, it would drastically improve your approach to software architecture:
https://www.amazon.com/dp/0132350882
https://www.amazon.com/dp/0201485672
https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
http://cc2e.com/
https://www.amazon.com/dp/0321127420
Focus on other aspects. Reading and being able to talk architecture has gotten me a lot further than the “cracking the code”, leetCode type of stuff.
(None of these are affiliate links)
https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164
https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420
https://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Signature/dp/0134757599
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
I'd start with a classic: Patterns of Enterprise Application Architecture by Martin Fowler. He blogs a lot on topics related to enterprise architecture.
I'd follow up with another classic: Domain Driven Design by Eric Evans. Martin Fowler has a lot to say about DDD as well
No worries, it's always good to make the implicit explicit. I am (and I suspect others would be as well) referring to Domain Driven Design.
"Domain", in this case, can be defined as the problem space that the software you're writing addresses. The business entities, actors, processes, activities, etc. that your software manipulates.
It will help -to me it was the first book that came to mind. The second would be the this -the pinnacle of software design.
The book Domain Driven Design: Tackling Complexity in the Heart of Software sort of revolves around this topic. The author speaks at great length about projects where spending way more time in modeling / researching than coding allowed them to solve the problems in ways which allowed them to scale way better - and what they did during that time.
The book is a bit old, but if you take it for the modeling aspect it's still a great read.
I think it's Domain Driven Design
For more foundational stuff, I'd look at:
Getting familiar with these branching models will also expose you to many commonly-used Git features like branching, squash merging, rebasing, tagging, and history rewriting.
No one's really gonna ask you about this, but you should develop a habit of writing great, clear, and concise commit messages.
All the rage right now - having real/near-real time building/unit-testing/packaging/deployment of your software once you've made a code commit. Read the articles I linked, play with services like CircleCI or Travis-CI or CodeShip and integrate them with your projects in GitLab.
Probably the two most commonly used overarching test-based software development processes. I'm a strong proponent of TDD (when done right), and many teams you work on will probably employ TDD or BDD.
Beyond those links, some books that cover a lot of general material are:
I presume it's Domain Driven Design -- This was a popular, well received book. DHH in particular has blogged, talked and tweeted about it on numerous occasions.
> Maybe now is a good time to step back and consider what kind of programming job you might want to target.
This is definitely something you should keep in mind. Try to become really awesome at one thing. That's not to say you shouldn't have a well rounded education in programming, just that someone who is simply ok at everything isn't getting a job anywhere.
Here are a few texts which I consider to be great for a novice programmer:
The C Programming Language : ANSI C
It's an older book, but it's still the best book to learn the language.
C++ Primer : C++
I used this book to get started with C++, and found it to be easy to follow and informative. Some say it's not a beginner book per-se, they may be right. I was already very familiar with C when I started.
Objective-C Programming: The Big Nerd Ranch Guide : Objective-C
If you're planning to write apps for Apple's iOS and OS X platforms, you're definitely going to need to learn this. Otherwise, don't bother.
Algorithms : Algorithms / Data Structures
This is not the be and end all authority on algorithms, but it's a great book. It's less theoretical and more concrete in my opinion.
I don't feel qualified to give recommendations for other topics like Java or web development, as those aren't really my strong suits. Happy hunting!
If your not afraid of math then I would recommend the books by Robert Sedgewick. His java book really shows off Java. His Algorithms book is a religious experience. And if your feeling masochistic, the Sipser book is well suited.
Nothing beats CLRS. But a decent alternative that is less dense is http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=sr_1_6?ie=UTF8&amp;qid=1410724273&amp;sr=8-6&amp;keywords=data+structures
I enjoyed this book and the author has an online course about Algorithms too.
Mastering Algorithms by Kyle Louden
Algorithms - 4th Edition : by Robert Sedgewick
Introduction to Algorithms - 3rd edition - Thomas H. Cormen
Tips and pointers for writing good Java code
http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683
Algorithms in Java with code examples
http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1416453105&amp;sr=1-1&amp;keywords=algorithms
For mobile development, check out the Big Nerd Ranch books. They contain guided projects that help you learn a variety of core features of mobile programming.
Thanks! Just to make sure, do you mean these two books?
If so, I'm glad you mentioned those. Both of them are already on my to-read list, but they were further down than Knuth's work. Since, as you say, they might better for starters, I'll check those out first.
By the way, I have also heard some good things about this one:
Have you any experience with that book? It's also on my to-read list.
https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X
website: http://algs4.cs.princeton.edu/home/
Doesn't the course offer a book? The professor might suck, but what about the textbook?
Otherwise, I think these two are the most commonly recommended algorithm books:
https://www.amazon.com/dp/032157351X
https://www.amazon.com/dp/0262033844
> Ako krene sa C naucice kako da stedi na memoriji i pise efikasne programe.
Ako krene sa C, odustaće posle trećeg segfault-a JER IMA 13 GODINA.
> [C previše komplikovan] nije
Možda ne tebi ili meni. Ali, evo, napiši mi kod koji će da u skup stavi imena gradova "London" i "Madrid" na C-u i onda to ispiše, onda ću ja to isto u Ruby-ju, i videćemo koliko je šta kompleksno.
> Vreme izvrsavanja je nebitno
Pogledaj sve, ali pogotovo slajd 8.
> Algoritmi na visokim jezicima... ne ide u istu recenicu.
Onda mi objasni zašto je najpopularniji udžbenik o algoritmima na Javi (ili pročitaj u njemu zašto je). Jedina druga poznata, CLRS, je u pseudokodu (jer je i Java previše low-level). Znaš li kako funkcionišu string-ovi u C-u? Hoćeš klince da učiš malloc i calloc i kastovanje void* ili kako funkcioniše tok kontrole?
In no particular order:
Structure and Interpretation of Computer Programs
Code Complete
C Programming Language(K&R)
The Pragmatic Programmer
The Mythical Man Month: Essays on Software Engineering
Introduction to Algorithms and/or Algorithms
Basic:
Building Java Programs
Interview Practice
Intermediate:
Algorithims
These are just a few books with good reviews that are also used in computer science curriculums at MIT or Princeton can't remember which and UW.
I can also post some basic ones too if you would like
No, no, no. The principle is great, but that book is bonkers.
You want the Vaughn books if you're doing DDD:
The bigger book: https://www.amazon.co.uk/dp/0321834577/ref=pd_lpo_sbs_dp_ss_1?pf_rd_p=569136327&amp;pf_rd_s=lpo-top-stripe&amp;pf_rd_t=201&amp;pf_rd_i=0321125215&amp;pf_rd_m=A3P5ROKL5A1OLE&amp;pf_rd_r=83Y7X80HPERQ5AMCEXGG
The shorter book: https://www.amazon.co.uk/Domain-Driven-Design-Distilled-Vaughn-Vernon/dp/0134434420/ref=pd_sim_14_2?_encoding=UTF8&amp;psc=1&amp;refRID=M5QXQ063YDX0E768HE3S
Source: read all of them tried getting traction across multiple teams citing them as sources, and the Evans book is almost intractable to most. Vaughn also at least starts talking about CQRS in a reasonable way, and introduces it using DDD.
He used the word "bounded context" using its meaning from Domain-Driven Design approach https://martinfowler.com/bliki/BoundedContext.html and that's what triggered Vernon who is the author of 2 books on this topic https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577 and https://www.amazon.com/Domain-Driven-Design-Distilled-Vaughn-Vernon/dp/0134434420/ . That's what makes this whole conversation funny.
This class on udemy is great, it covers absolutely everything about angular. https://www.udemy.com/the-complete-guide-to-angular-2/
Other than that if you want a strong understanding of the fundamentals you should invest some time in studying Object Oriented Programming and design patterns built on OOP. For instance angular uses the Decorator and the Observable patterns heavily. A good book on this is Head First Design Patterns, though it uses java code it may still help. It has a lot of pictures and psuedo code puzzles
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/ref=sr_1_1?ie=UTF8&amp;qid=1518933015&amp;sr=8-1&amp;keywords=head+first+design+patterns
Just think of these design patterns as mental tools, along with a little bit of coding syntax, that will help you elegantly handle more complex problems in your code. Using TypeScript lets you put all of the tools in that book to use.
Head First Design Patterns (2004) (homepage | amazon) was comparatively friendly and well regarded.
Head First Design patterns
The best book I ever read about Design Patterns is, no doubt, "Heads First Design Patterns" https://smile.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1466476241&amp;sr=1-1&amp;keywords=heads+first+design+patterns
Okay. Watch the official tutorials for sure, and I recommend looking at the tutorials posted on the /r/Unity3D sidebar fore more.
If you haven't already, learn some design patterns! Head First Design Patterns was an amazing resource for me. You'll learn how to organize code in ways that actually makes it readable extendable in the future.
I strongly suggest picking up the book Head First Design Patterns. The examples are in Java (but simple enough to do with no Java experience) and easily adaptable to PHP. It teaches best practices, design patterns, and coding principles and explains why they're good.
Once you start thinking and coding in design patterns you will be able to learn Unit Testing. After you know how to write Unit Tests you can then write code by TDD (Test Driven Development).
Edit: It's also imperative you know about PSR-0. It allows PHP to easily implement the SR (Single Responsibility) principal.
The Stanford Algorithm book is complete overkill in my opinion do NOT read that book. That's insane. Read it when you've been doing programming for a while and have a grasp of how it even applies.
Here's my list, it's a "wanna be a decent junior" list:
&#x200B;
Reasoning: So, the first book is to give you a sense of all that's out there. It's short and sweet and primes you for what's ahead. It helps you understand most of the basic industry buzz words and whatnot. It answers a lot of unknown unknowns for a newbie.
Next is just a list languages off the top of my head. But you can pick anything, seriously it's not a big deal. I did put Java first because that's the most popular and you'll like find a mountain of resources.
Then after some focused practice, I suggest grabbing some SQL. You don't need to be an expert but you gotta know about DBs to some degree.
Then I put an analysis book that's OOP focused. The nifty thing about that book, is it breaks into design patterns nicely with some very simple design patters to introduce you to design patterns and GRASP.
Then I put in a legit Design Patterns book that explains and explores design patterns and principles associated with many of them.
Now that you know how code is structured, you're ready for a conversation about Architecture. Clean architecture is a simple primer on the topic. Nothing too crazy, just preps you for the idea of architecture and dealing with it.
Finally, refactoring is great for working devs. Often your early work will be focused on working with legacy code. Then knowing how to deal with those problems can be helpful.
FINAL NOTE: Read the soft skills books first.
The reason for reading the soft skills books first is it helps develop a mental framework for learning all the stuff.
Good luck! I get this isn't strictly computer science and it's likely focused more toward Software Development. But I hope it helps. If it doesn't. My apologies.
This is a really good and easy to read book about design patterns.
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/
Gives you a good idea about basic concepts.
I'll let you know once I figure that out.
The biggest problem is that as cool as design patterns are, real world problems rarely, if ever, fit directly into the mold of a design pattern. Sometimes you need to combine multiple patterns. Sometimes you need to majorly tweak the pattern to make it fit your problem. Then there's question of, are you over-engineering your solution?
All hard questions to answer. The best way to know is... experience. Have real world experience of trying these things out. So to answer your question, the best way to learn how to use design patterns effectively is to use them on real world problems. Not a satisfactory answer by any means, but for some things in life, there are no shortcuts.
It's like answering, "How do you get good at public speaking?" The answer is to speak in public. There's no book you can peruse, there's no youtube video you can watch. You just have to do it again and again and again.
That being said, reading about design patterns is step 1. Everyone knows GoF. It's a really dry read. Personally, I own Head First Design Patterns. Very easy to read. I haven't bought the design pattern resource you listed, but I did read the freely available ones. Personally I think it's too simplified. Again, I highly recommend Head First Design Patterns. I wish there was Head First everything.
I've found that I gained most of my best experience on the job, and that staying at a job where I wasn't learning anything was a huge mistake and detriment to my career.
That said... I don't think I'm a super genius either. I did well in college and my GPA helped with my first few jobs. But I have lots of hobbies outside of work, and rarely spend my time at home thinking about the office. A lot of times companies aren't looking for the super genius type either... if they were they'd have a hard time filling staffing requirements. I think the keys are learning how to interview well, focusing on letting the interviewer know that you're willing and good at learning and having the basics of OOO down to a T. Come off as confident, even if you don't feel it. It never hurts.
As far as books go, here are some of my favorites:
Programming Interviews Exposed
Programming Pearls
Refactoring
I'm mostly a java programmer, so here are three absolutely necessary java books:
Head First Design Patterns
Core Java 1
Core Java 2 - Advanced
>How valuable is an Oracle cert?
No more than any other online course from a respected institution such as google, say: https://cloud.google.com/training/free-labs/ or one of the online courses available at MIT/Stanford.
>What else should I look into to boost my repertoire?
See if your university has any business partnerships you could do a 2-3 month project for. I worked with one of the university's here in the UK as part of a business/university partnership and that gives the students real world experience and us some free work. Win-win if the project is completed.
Sorry - mostly UK (amazon) links :)
TDD - https://www.amazon.co.uk/Growing-Object-Oriented-Software-Guided-Signature/dp/0321503627/ref=sr_1_1, Video by Trisha Gee whos fairly well known for speaking on this stuff: https://www.youtube.com/watch?v=QDFI19lj4OM (some very handy shortcut keys in the video and a good outline of some of the tools available to you).
Clean Code - https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 (by "Uncle Bob")
Design patterns - https://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1
Learn to use shortcuts in Intelli J to speed up your ability to generate/refactor code: https://www.amazon.co.uk/Getting-started-IntelliJ-Hudson-Assumpção/dp/1849699615/ref=sr_1_1
Also Jetbrains does good newsletters (curated by the same lady that made the video above under TDD) sign up to stay up to date with interesting/relevant blogs/articles/industry news https://www.jetbrains.com/resources/newsletters/
Github - https://www.amazon.co.uk/Version-Control-Git-collaborative-development/dp/1449316387/ref=sr_1_4
Bash Commands - https://nikgrozev.com/2016/05/22/shell-cheatsheet-part-1-common-bash-scripting-tmux/
XP/Scrum/Kanban development process - https://www.agilealliance.org/glossary/xp/ the way we work
Trusted developer blog on various engineering topics https://martinfowler.com/
Interview Prep https://www.hiredintech.com/courses
Hint: the above books are likely to be available at any academic library. If not, request them. you likely only need to read 33-50% of them and you'll be golden. I imagine you can likely get hold of electronic versions of these books as well.
The best thing you can do to prepare yourself is to start practising developing projects... get them up on github. it could be a website, a desktop application/game/tool, a demo of sorting algorithms, a web service... literally anything. Fork others' projects, code a feature request and create a pull request back to the original repository/codebase on github. Just build something rather than nothing. Anyone can do the latter. There's so much more opportunity now that we have github available. Think of any thing you might be interested in working on and someone, somewhere has likely already got a project underway in that area, and you're free to submit a pull request to their repository at the click of a button. This wasn't really possible 10-15 yrs ago.
The simple answer is there's so much to know, you just have to find what your interests/passions are and follow those as much as possible.
No matter how good you are at what you do today, the tools will be different tomorrow and may even depend on the industry you enter: AI, web services, blockchain, computer vision, robotics? The list is long and each one requires you to be highly trained (over many years) before you're considered any good at it.
Just try to learn what you can. Find something that genuinely interests you and study it until you become a trusted authority on the subject, or you find something you're more interested in instead.
If you have any ideas for the type of area you might be interested in put them up here and perhaps someone can point you to a relevant project?
https://en.wikiquote.org/wiki/Howard_H._Aiken "Don't worry about people stealing your ideas. If your ideas are any good, you'll have to ram them down people's throats."
I just chose some books that looked good from this list and this one.
The one's I got:
Clean Code
(already read)
Cracking the Coding Interview
Code Complete
Peopleware
Don't Make Me Think
Code (currently reading)
Regular Expressions Cookbook
Head First Design Patterns
C++ Primer
Working Effectively with Legacy Code
Elements of Programming Interviews in Java
The Mythical Man-Month
The Design of Everyday Things
JavaScript and JQuery
I figure that's enough reading material to last me until I graduate.
First of all, applause for the great start.
Here are some criticisms/suggestions I would like to offer. Keep in mind, I am not assuming your level/experience as a software developer:
> I force myself to write raw SQL Request to get better with SQL
while that is commendable, it is not really a good idea to write raw sqls in production code if there are ORM library alternatives available. Remember, it's not always you that is going to read/modify the code. While ORM syntax will be fairly universal, your style of writing SQL may vary starkly from other people - which is what creates confusion and lets errors sneak in. Even if you want to do that, maybe keep the raw sql in separate modules (point 2).
Finally, remember that all these are just suggestions, and you may already know them. You will decide which ones to take and which ones to leave behind based on your situation.
Again, great job (I also learnt something from this). Just make sure you keep running.
> Have a lot to learn about OO
Read Head First Design Patterns. It is written in a style that is super-corny but actually sticks in your head really well. Also, the syntax it uses is java, but you don't need to know how to write Java.
Learn how to write Automated tests. They will help keep you from spending late nights hunting down bugs. Test-Driven Development with Python is excellent and free.
Also, learn to use assertions and pdb to find bugs.
Learn how to set up your development environment and servers. I recently wrote a tutorial on this and would be grateful if you would check it out and give me feedback: https://amfarrell.com/saltstack-from-scratch/
One thing that's awesome about Python is the language itself helps solve a ton of the gang of four's design patterns. That said, I really appreciated reading Head First Design Patterns because it helped me understand what I already did intuitively better https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/ref=sr_1_1?ie=UTF8&qid=1540609515&sr=8-1&keywords=head+first+design+patterns&dpID=61ZG-hATOeL&preST=_SX218_BO1,204,203,200_QL40_&dpSrc=srch.
If you did the Princeton Algorithms course and have two years experience as a professional developer you're way too advanced for CS50 and other intro classes.
The classes I'd recommend for someone in your position are:
More than the above though I'd recommend learning the following concepts and subjects even though there aren't any good MOOCs on them (to my knowledge):
Regarding a dictionary: not that I know of, no unfortunately.
Also no, programs are not always laid out in the same fashion. There are the concepts of design and architecture. For the purposes here, I'm going to define architecture as how the entire system/program is put together, from the highest-level. Often this involves modules that each contain multiple classes (in OOD). Design, on the other hand, I'll define as how a small number of classes, within those larger modules, are related and interact. This is usually a class diagram in UML. Large scale vs. small scale essentially.
Architecture's goal is reducing risk and ensuring that the application/system exhibit certain non-functional requirements (or quality attributes in SEI-speak). These are '-ilities'. E.g., security, maintainability, modifiability, testability, but also time-to-market, performance, etc. One of the things to remember with architecture is that it encompasses not only the compile-time structure of the code, but also the runtime structure, the deployment (systems-level) structure, and the relationship to other systems (context) and, potentially, time.
While design also influences (and is influenced by) the non-functional requirements, it also concerns itself with data encapsulation: what data should be contained within what objects and how should it be accessed and modified, how tightly coupled and cohesive they should be.
Suggestions for architecture books (these are the two I have personal experience with):
Suggestions for design books:
For OOP Design Patterns also check out:
These are books I actually own and would recommend. Of course there are other great/better books out there, but I'm going to stick with what I've actually bought and read or "read".
I say "read" because several books are NOT meant to be read cover-to-cover. These typically have about 1/3 that you should read like normal, and then skim the rest and know what's in the rest so that you can quickly reference it. These books are no less important, and often even more important. I've marked these kind of books as #ref for "read for reference". Normal books that should be read cover-to-cover are marked #read
For learning your first language: This is really the hardest part and unfortunately I don't have any books here I can vouch for. I started with "C++ for Dummies" and am not including a link because it's bad. Your best bet is probably "Learning <language>" by Oreily. I also love the Oreily pocket books because you can carry them and skim while on the bus or the john, but you can just do the same with your smartphone. Pocket Python, Pocket Java, Pocket C++
Top Recommendations:
Accelerated C++ #read Made for people who already know another language and want to pickup C++. Also great for people who need a refresher on C++. I really like how it doesn't start with OOP but gets you familiar with the imperative parts of C++ before diving into OOP.
The Algorithm Design Manual #ref This is my new favorite book and the first I would send back in time to myself if I could. Each algorithm & data structure is given a mathematical breakdown, pseudocode, implementation in very readable C, a picture (very helpful), and an interesting war story of how it Saved The Day.
Cracking the Coding Interview #read I originally avoided this book like the plague because it represented everything I hate about coding interviews, but many interviewers pull questions straight from this book so this book can equal getting a job. Put that way, it's ROI is insane.
The Pragmatic Programmer #read Must-have for any profressional software engineer that covers best-practices for code and your growth. You can also find the raw tips list here
Head First Design Patterns #read Many prefer the "GoF/Gang of Four" Design Patterns which is more iconic, but Head First is a modern-version using Java to cover actual design patterns used day-to-day by programmers.
For Intermediates:
Effective Java or Effective C++ and Effective Modern C++ #read When you're ready to go deep into one language, these books will give you a huge boost to writing good Java and C++.
Design Patterns #ref You'll want to get this at some point, but early on it's too much for a beginner and many of the patterns are obsolete.
The Art of Computer Programming #ref The programming "bible" but like Design Patterns you should hold off on this iconic book until you've got your basics covered. It would make for a great purchase with your first paycheck or first promotion :)
I think the Head First Design Patterns book is actually pretty good. Some might knock it due to its silly and childish nature, but that's part of the reason why I like it.
http://corner.squareup.com/2013/05/retrofit-one-dot-oh.html
^ start there
DAOs & factory are design patterns. Old book but good: http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124
Caching + retrofit
https://gist.github.com/swankjesse/5889518
This example is dated. I'm using okhttp 2.0 + retrofit 1.6.1 so it doesn't quite look like this, as the example uses older libraries, but is similar.
I'd share code but I signed documents stating I wouldn't do that, and I like paychecks :P
If you are looking toward application development(games or otherwise) I'd suggest looking at more practical beginning programming books, don't even worry too much about making a game yet or building complex algorithms. I've found the Head First series fairly good in the past, so maybe try out https://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208
Once you get your head around basic application development a bit more, I would highly suggest learning design patterns and can fully recommend the Head First book on that topic.
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
You can follow that up with the Game specific book on patterns, https://www.amazon.com/Game-Programming-Patterns-Robert-Nystrom/dp/0990582906
With all of that you should have enough to start asking more pointed questions and being able to Google up useful answers and tutorials that will get you on the road to building games.
Edit: That said, if you are looking at doing to extensive AI programming, specializing in engine design or other systems type development, start looking for books on the topic that interests you most. It's pretty easy to Google up book lists on these kinds of topics, and from there you can cross reference recommendations and should be able pick out ones that will help you get started.
Heh, sure.
A lot of people are fans of Code Complete. I tried reading it after being in industry for a decade, and I found it to be very dry and boring. The general consensus from people that I've talked to is that it's more useful when you're just starting out. Maybe I just came to it too late.
A better book (in my opinion) in that same vein is Clean Code. Clean code is shorter, more focused, and has better real-world examples. It feels less "complete" (hue hue) than Code Complete, but to me, that's a strength. As a quick point of comparison: Code Complete devotes 32 pages to the chapter on identifier naming; Clean Code devotes just 14.
I got a lot out of Design Patterns. I seem to recall that the pattern fad was in full swing back when I read this in 2005-ish. I think I had independently discovered some of the patterns already at that point, but this book helped me to codify those ideas and also showed me some new ones. Some of these patterns are now seen as antipatterns (I'm looking at you, Singleton!), and all of the patterns have an object-oriented bias. But there's still something useful in the pattern language, and this book is a reasonably comprehensive start. The book is somewhat dry, and some people report that Head First Design Patterns is a gentler and friendlier introduction. Head First Design Patterns hits the essential patterns, but misses a lot of the less popular ones.
Eventually, you'll need to work in a codebase with some technical debt. Maybe it's debt that somebody else put there, or maybe it's debt that you introduced. Working Effectively with Legacy Code is still my go-to recommendation. It defines technical debt as code that is not under test, it introduces the idea of "seams" that you can use to pry apart code that's too tightly coupled, and it then provides a cookbook of specific scenarios and reasonable approaches.
If you're looking for thought-provoking videos, I recommend anything by Rich Hickey. I don't know if I've watched all of those, but I remember good things about Hammock Driven Development and especially Simple Made Easy.
Get comfortable with a source control system. I didn't use source control in college, since it wasn't needed for any classes, and that was a missed opportunity. The whole world loves Git, so you'll probably want to learn it if you haven't already. But I'll also toss out a recommendation for Mercurial. I haven't used it in years, but I remember finding it to be quite good.
Good luck!
You are on the right track. The most important to understand is the fundamentals of any programming language. You mentioned Java. Java is an object-oriented programming language. In order to write good code in Java, you will need to learn what is an object? What is object-oriented? Like, what is inheritance, polymorphism, classes, interfaces etc etc. Once you learn the concept of OOP and you want to learn Python (another OOP language), it will be that much faster, because you already understand the concepts. Python has its nuances but you learn as you go along. I think you should start with the Head First series by Oreilly. They are sooo good at teaching this sort of stuff. I will give u the links below:
Head First Java
Head First Object-oriented Analysis and Design
Head First Design Patterns
Buy just the one book and start from there. Checkout the Head First series, you may like other books too. Also, google 'design patterns' and read about it. Some people mention Algorithms and that is all great stuff and you will learn as you write good code. There is another book I would recommend:
Pragmatic Programmer
I would also suggest that you should try different types of programming languages as well. Like functional (LISP or Scheme) or procedural (C). When you do that you will start to think differently and it will expand your knowledge. LISP was created in 1958 by John McCarthy. My friend works at Google and he told me that they are using LISP behind Google Maps.
In terms of practical, professional skills, here are a few I would recommend:
For more tailored recommendations, where do you feel that you're weak? There are plenty of college textbooks that can introduce you to algorithms, but if you have an end-goal in mind, you can really focus your learning. Work on some tougher projects than you're used to, and study open source code that does interesting things.
I graduated and started working this summer. One of the senior programmers handed me this book. Head First Design Patterns
> ...and then rewrite the whole thing to learn why composition is better than inheritance
This.
'Extends' is evil, and should be used as a delicate seasoning in your design, not the key ingredient.
If you don't know why we say this, start here:
Head First Design Patterns
Read books. It might be boring, but a lot more informational than watching a youtube video.
If you already know how to program in another (preferably OOP) language there's The C++ Programming Language or C++ Primer if you want to learn C++11 (not to be confused with C++ Primer Plus, which is a different book 'series')
If you don't know how to program and you want to learn C++ for game development there's Beginning C++ Game Programming, which starts at the beginning (variables are one of the first things explained). After that book you should read up Introduction to Algorithms to make sure you're not writing horrible inefficient programs. Then there's Design Patterns: Elements of Reusable Object-Oriented Software to teach you more about certain patterns used in programs design (needed when using Ogre3D for example. Ogre3D was 90% magic to me until I read about Design Patterns. :p As alternative to DP:EoROOS there's Head First Design Patterns, but it's Java-centric which is a whole other beast than C++.
After those books there's this Stackoverflow thread. Read the first answer (the gigantic list of books). The thread used to be a ton of comments (with the most votes comments on top), but all anwers got copied to the first comment, so it's all sorted on votes. Code Complete (2nd edition) was the most upvoted one, The Pragmatic Programmer was the 2nd most upvoted one, etc.
Then there's this Stackoverflow thread, which is more C++ centric.
I hope this helps :)
I would suggest checking out design patterns if you haven't already. Even if you don't find direct applications of patterns in your project, you will probably gain some insight into good oop techniques. Check out the gang of four book or headfirst design patterns.
True, well in case anyone would like to learn more about design patterns, this book is awesomely corny and easy to read. Doesn't matter if you don't know java at all.
http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124
And read this before you start the book as it's probably the most important point they kind of just ignore.
http://www.codinghorror.com/blog/2005/09/head-first-design-patterns.html
>I want to make more applications...but I don't have any ideas..is there any reading you would recommend me to do?
Have you read Head First Java?
Head First Design Patterns?
The pragmatic programmer?
>I want to be employable...after 3 years doing a computer science course, I feel like I still only know the basics. What Java books do you value most and feel helped you become a much better programmer?
In my particular case, I didn't read books. My interest has been developing web applications, so I have gotten more information from frameworks' documentation an tutorials than from books.
>What are some examples of programs you made when you were 1 or 2 years into your Java programming career?
Hmm... I created some plugins to check on the availability of some servers and services. When it detected those were unavailable, it sent email and SMS alerts to our system administrators. Things got interesting when the email server was down tho.
>What resources would you recommend me reading to understand how to make my android applications able to access the internet..so that users can compare high scores and achievements?
>I have the drive. I love programming and I want to be a successful one. What advice can you give me?
Code as much as you can. Check what kind of applications you want to develop and find which frameworks can help you build them. You don't need to re invent the wheel (unless necessary). Follow the developer's guide and check if there are any tutorials that you can use to improve your knowledge and make better applications in the better way possible.
>Thank you for your help. I really appreciate it. I've felt stuck for days and i honestly did browse a lot before I came here. I've seen a lot of Java developer jobs paying £20-40k but i feel i don't have the relevant experience to even apply to them yet. I feel like i know very little..I.e I have no idea what J2EE is and what it's used for.
From wiki:
"Java Platform, Enterprise Edition or Java EE is Oracle's enterprise Java computing platform. The platform provides an API and runtime environment for developing and running enterprise software, including network and web services, and other large-scale, multi-tiered, scalable, reliable, and secure network applications. Java EE extends the Java Platform, Standard Edition (Java SE)[1], providing an API for object-relational mapping, distributed and multi-tier architectures, and web services. The platform incorporates a design based largely on modular components running on an application server. Software for Java EE is primarily developed in the Java programming language and uses XML for configuration."
If you want to build enterprise web-enabled applications, this is what you should start reading:
J2EE 6 Tutorial
And I always recommend these as well, they helped me a lot when I was learning Java Server Faces:
http://balusc.blogspot.mx/
http://www.mkyong.com/ (He has an Android tutorial that might help with with your interest to develop applications for that OS)
http://www.coreservlets.com/
Upvotes for Head First Design Patterns, it's a great reference and fun read!
While Design Patterns is the original book, I feel most people are better suited to getting books that were published later that make the first Design Patterns more digestable. DP is a good reference to have on the bookshelf for any software developer but I feel if you're new to Design Patterns:
A. There are better free online sources for the raw Design Patterns in the GoF book like this website
B. There are better books out there for explaining Design Patterns in the GoF book to newbies like Head First Design Patterns
If you want to know some algorithms that are handy when designing systems to work together, read Head First Design Patterns. It's a pretty light read but if you do most of their exercises, it sticks pretty fast.
Just break down the problem into smaller and smaller chunks. Come up with a few systems, a map system where the grid is stored(i.e. 14,17 is a barracks and belongs to room id #115.(also, make it a singleton so that the building system can ask it wheres free)) and then the room system(pretty much just manages a collection of the rooms built) which keeps track of all the rooms and updating them every tick, and then have a Collection system that is a listener to all the rooms and will pop up showing that they need to be collected, then have the unit system where all the characters are stored, and probably a movement system to track which characters are moving where, and more systems as you build it bigger. Then a game StateMachine(which would probably be the dominant system and passes updates to all the other systems) to keep track of what to menus to be showing the player, and when to take input to the map or whatnot.
If something doesn't feel good to work with, refactor it and try to think of a simpler way to use it. It's a big task, and you shouldn't try to fit the whole thing in your head at once.
I'll tell you my approach. I use c# to make windows applications used internally at a college that usually display student and loan information. I use a couple patterns (unit of work / repository and mvp.)
I break my project down to multiple layers (data, domain, service, presentation, and view).
My domain layer simply holds poco classes. That's plain old clr objects (classes with only public properties). Each class represents a table in my database and each classes' properties represent a field in that table. This layer also holds my validation classes.
The data layer is used to interface with my database. I use Entity Framework as my ORM and wire everything up using generic repositories and a unit of work.
My service layer is the middle man between my data layer and the rest of the application. It defines and implements what I can do against my database. For example: StudentService.GetAllActiveStudents() or CampusService.GetTeachersByProgram() etc...
My presentation layer is, well, the 'P' in MVP. And my view layer is the 'V'. Look up mvp pattern if you're interested.
The beauty of doing it this way is that everything is loosely coupled from everything else. I can switch out my data source and only have to change code in my data layer. I can write a new user interface that implements the view interfaces defined in my presentation layer and i know it will work. I can allow another application to use my service layer (create an api) for reuse. And the real beauty is that everything is testable. I follow test driven development pretty hardcore and doing it this way allows me to unit test everything.
I don't want to go to into detail about what each of these layers do because that information is easily found from google but the point is is that there are patterns out there which define how you design your project, how you break up your project into layers, and what those layers are responsible for. You might want to check out the book Head First Design Patterns. It uses java examples and it's really good at putting patterns into perspective.
I enjoyed http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124 though it's not language-centric if you're looking for that.
In my experience, languages are pretty easy to pick up once you know one. I think you'd be better off sticking with Java and exploring concepts, algorithms, data structures and certain frameworks.
When I was starting I got a lot out of the GoF Book. It's a C++ book but they don't really use any C++ features that are hard to translate to Java. I've heard good things about Head First Design Patterns too but haven't read it.
As far as Java goes Spring and Hibernate are two great libraries to be familiar with, since you'll encounter them in the wild pretty regularly.
If I were to suggest something you might not have learned, consider installing VirtualBox and using it to run Ubuntu. Familiarity with Linux will give you a big leg up and Ubuntu is a pretty good way to ease into it. Plus it has packages for a ton of different programming languages so you can experiment with any that catch your fancy.
Objects are for grouping related data and methods together. It really is as simple as that.
Start off by writing applications where you're just creating and consuming objects, not writing your own classes. Java and .NET both have tons of libraries that contain a wide assortment of objects. You mentioned C#, so write a few .NET apps. Try to start identifying and understanding the way properties and methods are grouped into objects, and how the different objects relate to each other.
Once you're comfortable using objects, then you can start writing your own classes. A lot of universities try to teach this by having you write common data structures. This approach is worth considering, as it's important to be familiar with data structures, but this isn't the only way to learn object-oriented programming (nor the best, in my opinion). Another commenter recommended writing a video game, which sounds like it's worth a try. Ultimately, the right approach is the one that interests you the most.
Getting good at OOP will take some practice, but it is possible. Objects are like functions: they should do one thing well. Enforce separation of concerns. Learn the design patterns. Practice makes perfect(-ish).
Recommended Reading:
A book I recently read that helped me understand the important and implementation of design patterns was [Head First: Design Pattern](Head First Design Patterns: A Brain-Friendly Guide https://www.amazon.ca/dp/0596007124/ref=cm_sw_r_cp_apa_i_3hEdBbDFGPCP6) . The book introduces the concept in an informal way and makes the learning experience fun and worth it.
The book Head First Design Patterns really helped me get my head around objects. I'm still nowhere near an expert, but it is a very engaging workbook.
Work your way through a book on object oriented programming. This is one of my favorites: Head First Design Patterns: A Brain-Friendly Guide https://www.amazon.com/dp/0596007124/ref=cm_sw_r_cp_apa_i_nGu7Ab5ZBTF2A
It's simple, repetitive, and thorough. It's almost impossible not to learn from it. Some people find it too repetitive, but I think it's great if you don't have much experience with design patterns.
Okay, so this is a very popular book for mainly OO design prinicples:
http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124
http://eloquentjavascript.net/
Also very popular, though Javascript inherently uses a lot of functional programming that might be confusing if your language of choice doesn't make use of first class functions.
http://www.youtube.com/user/derekbanas?feature=
That guy ^ goes over like every design principle you can imagine.
I've also heard that this is great:
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
It seems to me you have set the bar too high. Searching and sorting algorithms alone are one semester course and are programming language independent. You are not tied to Java to learn them, though coding them up in Java will help you come to grips with the language.
If you really want to learn the language, then try to implement the first part of your goal that is stacks, queues, linked lists and binary trees. Do not let the jargon "...data abstraction as applied to elementary ..." come in between. Ask your faculty in helping to write efficient and robust code, that is make your stacks, queues, lists and trees take any sort of data that is use generics they are a big thing in Java. This will help you understand how to make your code be able to serve any type of data.
After you have done the coding of these data structures compare them with the libraries that Java provides for list, stack, queues. This comparison will give you insight as to how to write better code in Java.
Also try to learn a few patterns while coding these things up. For starts you can go to sourcemaking or look up at the book Head First design patterns. You may get lost here or overwhelmed, so do ask your faculty for guidance here as to what you should cherry pick to get the best footing.
Congratulations, and all the best for your job!
I'm new myself, so I can't offer direct criticism myself, but I thought I'd share the book I'm reading now that I find helpful for learning design patterns.
[Head First Design Patterns]
(http://www.amazon.com/gp/aw/d/0596007124/)
Awesome design patterns book Head First Design Patterns
[Edit] The patterns are expressed in Java
https://www.amazon.com/Head-First-Object-Oriented-Analysis-Design/dp/0596008678
My other recommendation is that you get this person immediately implementing as many design pattern tutorials as possible because their usage comes in stages.
The first stage -- everything can be solved by patterns. This is where patterns are used excessively and without reason just because this is a new tool to work with.
The next stage -- sometimes a pattern is overkill. The programmer realizes that sometimes the problem can be solved more clearly and easily without implementing 9 patterns to do it.
After that -- I hate patterns. I hate classes. I hate OOP. I think I'll learn C.
Eventually -- Yeah, OOP works well for some things, and not so well for others. And, sometimes patterns are useful, but a lot of times it's not really worth the technical debt. So, I'll use discretion in introducing a pattern, and I'll try to keep it abstract enough that the pattern doesn't get in the way.
So, you can probably guess that these stages take a long time to get through. That's a lot of failed code, fragile code, brittle code before things get better.
This is why I suggest you start them on it while learning about OOP.
Maybe get a book? I've heard good things about the Head First series.
When I was still in school a few years ago, yes there are universities that offer courses specifically on software architecture, usually as a senior-level or graduate-level course. Most require some industry experience as a prerequisite.
There's also apparently a free Udacity course by Georgia Tech.
> I need to understand this fairly well to evaluate companies in the ecosystem.
Much like design, there is no "good" or "bad" architecture; it is only useful in solving certain problems, or it is not useful. Architecture is influenced by the requirements of the product, products, or product lines they are delivering, but also the existing technical environment (I assume that's what you're thinking of evaluating), and the organizational structure of the company. See this excerpt from Software Architecture in Practice.
Without understanding the full context of which the "architecture" was created, it is actually quite difficult to evaluate. Sometimes it is obviously underperforming because the negative effects are extremely visible. But even if it looks ok on the surface, it may be flawed on the premise of satisfying stakeholder requirements, which is even hard for engineers working on the product.
> I imagine that learning it well enough to communicate with developers and understand business use cases and competitive advantages of certain innovations in the space is the end goal.
If this is your goal, then learning more about software requirements sounds like the better approach. This aspect of software engineering directly addresses your business use case concern. Software Requirements by Weigers is pretty good.
> I found a full stack web development specialization at coursera - does that sound like the type of course that might cover all this?
No, that teaches implementation for a specific stack and a architecture - Angular, NodeJS, Ionic, Express, and MongoDB using a Client-server architecture. It doesn't teach you how to critically analyze a system.
The o'reilly "site reliability engineering" book was well worth reading imo
https://www.amazon.com/Site-Reliability-Engineering-Production-Systems/dp/149192912X/
This one
Site Reliability Engineering: How Google Runs Production Systems
Free Online: https://landing.google.com/sre/book.html
Amazon: https://www.amazon.com/dp/149192912X/ref=cm_sw_r_cp_tai_wxJdAbNKAZKZH
The SRE book
https://www.amazon.com/Site-Reliability-Engineering-Production-Systems/dp/149192912X
Just read Tanenbaum's Operating System's Design and Implementation, and Lions' Commentary on Unix and you should be good to go.
If we are going to talk about a good new netsec book, I recommend everyone check out "Tobias Klein's" - A Bug Hunter's Diary. You can get it at nostarch.com but I recommend saving the cash and getting it from amazon.com. I got my copy on Monday and its been a pretty good read so far.
I've read a lot of these but I'm glad to see not all of them :) Adding to my reading list for sure.
Thanks!
EDIT: forgive me if these are already listed but just in case...
Bug Hunter's Diary - http://www.amazon.com/Bug-Hunters-Diary-Software-Security/dp/1593273851
Gives real hands on real-life experience in a "diary" format and covers some great bugs
Gray Hat Hacking - http://www.amazon.com/Hacking-Ethical-Hackers-Handbook-Edition/dp/0071742557
Despite a bad generic "ethical" title this book goes really in-depth on a lot of subjects (almost to the point of rambling actually) including fuzzing, client-side exploits (mostly browser-based), and much more.
Hacking Windows Exposed - http://www.amazon.com/Hacking-Exposed-Windows-Microsoft-Solutions/dp/007149426X
Another generic title but this book has small good parts scattered throughout, really written more for pentesters it has some very common red team methods but also has a few hidden gems hidden within the various subjects it tries to cover.
Also for anyone looking to get TAOSSA (The Art of Software Security Assessment) it's absolutely huge and WILL split down the middle while reading...it's sitting on my bookshelf right now in its ripped state but I've read it 4 times and still don't feel like all the material has sunken in, if you're going to buy any book at all it should be that one as it will provide countless hours/days/weeks/months of reading.
I haven't done this myself yet but I'm pretty sure this is where something like Ida Pro comes in where you disassemble the program so it is now in assembly language. Then you can use your assembly language skills to step through some of the code. Like you may see variables stored in a weird ways or memory handled in a bad way.
A book that may get you started is: The Bug Hunters Diary
https://www.amazon.com/dp/1617292230/
https://www.amazon.com/dp/1680502441/
https://runestone.academy/runestone/books/published/pythonds/index.html
None. I'd still be going for looks on the beach. Don't read a programming book. Read a theory book, like Head first design patterns (it's got a cute chick on the front).
http://www.amazon.com/Head-First-Design-Patterns/dp/0596007124/ref=pd_bbs_sr_1?ie=UTF8&amp;s=books&amp;qid=1209838842&amp;sr=8-1
Take a look at this: http://blog.ircmaxell.com/2012/07/oop-vs-procedural-code.html
Just because you're using objects does not mean it is OOP. OOP is much less a "way of doing things in PHP" and much more "a way of doing things" in general. It's the use of these patterns, and following principles of OOP design (the three pillars[1]), that determine if your code is OOP or not.
If you're looking for a book, I recommend Head First Design Patterns. It's targeted toward Java developers but nearly all of the ideas apply to any OOP language.
[1] This is a good reference about the three pillars. It's an excerpt from a C# book, but again, the principles apply to any OOP design.
"Design patterns" are the function use of oop so from a learning perspective I would suggest starting there (assuming you understand the fundamentals of programming of course)
I loved head first design patterns but the GoF book : Elements of Reusable Object-Oriented Software is pretty awesome albeit a bit heavy for learning.
Just to piggyback on OP's question (because I'm interested in the same thing), does anyone have any opinion on Head First Design Patterns?
I was looking at that before I saw this thread.
Design Patterns (Head First).
It's the "gang of four" patterns covered in a somewhat silly way to help you learn it. Teaches you some very good stuff.
I'd get the gang of four book for a reference, but get the Head First one to learn them first. It's not precisely pure OO, but it teaches you concrete ways to apply good OO practices, such as (the most important one IMHO) favoring composition over inheritance.
Just go for the "Head First Design Patterns" (the gang of of four one is good but very arid and I would not recommend it as a first book). The "Head First" series is very user friendly.
my path from pre-oop to feeling like I finally understand why to use OOP principles and when / how to implement them has been:
cakephp (briefly) > yii > laravel > Symfony 2 > starting now on ZF2
shortly after getting serious with learning MVC for work reasons, I started by trying to use a framework. I experimented with various - and only really got a basic grasp of why after trying yii properly for a project.
I then redid the project in laravel - improving it but it was still a complete shambles really.
Then I got the headfirst design patterns book:
http://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?ie=UTF8&amp;qid=1369730778&amp;sr=8-1&amp;keywords=headfirst+design+patterns
I cannot recommend that enough.
It's in java but you should be able to grasp it - the main thing is the way constructors are named after the class name in java threw me at first, but after that, its very similar indeed.
Don't pirate that book either - I have tried it in pdf and I bought it in the end, as its not a very easy book to read if you dont have it on paper.
From there, I read about half that book and was able to apply what I had learned to how these MVC frameworks were working - and that was without ever touching the MVC chapter.
Learn about why / how to abstract, factories, why programming to interfaces is super important, and a ton of other things that will take you from being somewhere around beginner / intermediate, to comfortably intermediate heading towards advanced.
The basic ideas you're looking for are 'design patterns'. If you've ever browsed through code and saw class names like FooFactory or BarPublisher or QuuxVisitor, you've seen design patterns in action.
The 'canonical' book on design patterns is often referred to as the Gang of Four book.
But, it's fairly dense. I recommend the this one instead, it's a more efficient read.
Headfirst Design Patterns (pardon the ugly cover), this book easily illustrates and explains software engineering patterns that many would consider essential to writing good software. I'm currently in my senior year of Computer Engineering with a Software Emphasis and patterns are very important for writing manageable, maintainable, and readable software. (apologies for ugly link)
Amazon: https://www.amazon.com/gp/aw/d/0596007124/ref=mp_s_a_1_1?ie=UTF8&amp;qid=1487231105&amp;sr=8-1&amp;pi=AC_SX236_SY340_FMwebp_QL65&amp;keywords=head+first+design+patterns&amp;dpPl=1&amp;dpID=61APhXCksuL&amp;ref=plSrch
Something else I recommend is buying a raspberry pi and setting up a basic home web server, you can Google easily how to so this. This is a fantastic introduction to full stack development and the possibilities are endless.
Hope this helps, good luck!
Edit : I also work as a software developer and will be working there full time when I graduate.
This book is chock full of good design patterns and written in Java. Much of the code will translate very nicely to TypeScript: https://www.amazon.com/Head-First-Object-Oriented-Analysis-Design/dp/0596008678/ref=sr_1_8?ie=UTF8&amp;qid=1496408897&amp;sr=8-8&amp;keywords=object+oriented+programming
Of course, it's not the only book, but I found it really useful.
I've been writing a book on TypeScript and just finished the first cut at TypeScript classes. It has a number of examples. They are very simple, but get into interfaces, classes and so forth. Here's the link: https://pagalvin.gitbooks.io/yet-another-typescript-book/content/
Classes are covered in chapter 7 and especially chapter 8.
Programmer here.
"If you cannot explain it simply, you don't understand it well enough."
What I'm trying to say is that a good programmer can always find ways to simplify a concept, or explain it using real-life analogies, even to people who don't know anything about programming or computers in general.
This is actually one of the most important qualities of a good software developer - the ability to rationalize often complicated abstract concepts in simple terms and break them down into simple tasks.
I want to make this clear - I am not saying that your boyfriend is a bad programmer and I don't know his professional level.
However, it sounds like both of you could turn this situation to your own benefit.
If he makes an effort to explain his work in ways that you could understand, it would work in his favour in the long term, and you could share his excitement.
I actually recommend reading Head First Object-Oriented Analysis and Design: A Brain Friendly Guide to OOA&D for easy-to-digest examples of complex issues in software development, explained with tools and objects from everyday life, he could probably take a hint from that book and learn something.
Finally - big props to you for being a supportive girlfriend and taking interest in his work.
Thanks! I've come across that book, and also another one, Head First Object-Oriented Analysis and Design LINK
Have you used this book? If so, which one do you find better for my situation? (Amazon user reviews says this book has quite a bit of errors and was rushed, leaving things out) :/
This series of books is also very good for beginners!
https://www.amazon.co.uk/gp/aw/d/0596008678/ref=mp_s_a_1_1?ie=UTF8&amp;qid=1504991665&amp;sr=8-1&amp;pi=AC_SX236_SY340_FMwebp_QL65&amp;keywords=head+first+design+patterns&amp;dpPl=1&amp;dpID=51mE7FBCw8L&amp;ref=plSrch
Coming from HTML, you'll need to get your head around a few key words and concepts, object oriented programming, polymorphism, class hierarchy etc... It can be daunting at first but once you have the basics everything else is just application (which can take a while to get quick at).
Head first also have a design patterns book, which is useful if you're on a project which you're designing fresh...
Need TEST BANK for the following textbook. PM me ASAP!!!!
&#x200B;
Software Requirements, Third Edition, Wiegers and Beatty, Microsoft
Press, 2014. ISBN-13: 978-0-7356-7966-5
&#x200B;
Amazon link: https://www.amazon.com/Software-Requirements-Developer-Best-Practices/dp/0735679665/ref=sr_1_fkmr0_1?ie=UTF8&qid=1539023244&sr=8-1-fkmr0&keywords=Software+Requirements%2C+Third+Edition%2C+Wiegers+and+Beatty%2C+Microsoft+Press%2C+2014.+ISBN-13%3A+978-0-7356-7966-5
&#x200B;
&#x200B;
Software Requirements (3rd Edition) (Developer Best Practices) https://www.amazon.com/dp/0735679665/ref=cm_sw_r_cp_apa_i_91JMDbRFCPG5X
Software Requirements
Take a look at the IIBA (International Institute of Business Analysis) and pick up Wiegers' book on Software Requirements.
It depends on how much it interests you.
You can play the whole game without reading any lore if you want.
To get the story of a certain area or zone - read the quests and do your best to do the whole area to competition.
> Also what is a good place to read about wow lore?
I actually don't know. o__o I've been thinking about looking more into myself. They have some books that are good. I enjoyed The Last Guardian. They useally do books before expansions such as War Crimes for WoD and The Shattering for Cata.
There are also a lot of youtubes that talk about it as well though I haven't watched them myself.
Ok, so now that I'm not at work and can actually post in detail-
yes. Everything /u/evilresident said is correct. If you take the entire story itself they're all fantastic. However, I think we all have those writers we do and don't like because of their writing styles that take you out of the story.
I am a major fan of Christie Golden's books. Her word choice and close attention to detail (along with Blizzard's obvious help) kinda brings the book to life and you can just FEEL what's going on. I also recommend from her The Shattering: Prelude to Cataclysm. Equally fantastic as Arthas.
The only thing I have about Richard Knaak is that although the books he writes are usually really good, his vocabulary is limited and it kinda shows. I want to say it was Stormrage where he used the word orbs to describe eyes like six times in a single chapter. The book was really good, but it was the lore itself that kept me involved more than the writing.
I'm also tend to nitpick. Either way, no matter which book you read you're in for a good time.
Have you read https://www.amazon.com/Site-Reliability-Engineering-Production-Systems/dp/149192912X already? It covers a bit of who/how they hire along with what they do. Might help some. Good luck!
>How did you get started in DevOps?
I watched https://www.youtube.com/watch?v=LdOe18KhtT4. I realised this was the future and if you wanted to be in a high performing organisation you need to do what they're doing.
Unless you're in an organisation that is willing to undergo the cultural change of Operations and Development working together you're probably not going to go far. Creating a devops organisation from scratch is HARD unless everyone is on board.
Looking into the technology is the simple part, try reading around the movement. Pheonix Project (http://www.amazon.com/Phoenix-Project-DevOps-Helping-Business/dp/0988262509) is a good start, from there I'd look into Continuous Integration and Continuous Delivery (https://www.amazon.co.uk/Continuous-Integration-Improving-Software-Signature/dp/0321336380 & https://www.amazon.co.uk/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912).
If by this point you don't know a programming language you're going to be in serious trouble. Learn something, be it Powershell (and honestly you probably will want to move onto C# if you want to be amazing at what you) or Python/Ruby.
Honestly you should be working towards what Google does with SRE if you want to be at the leading edge. https://www.amazon.co.uk/Site-Reliability-Engineering-Production-Systems/dp/149192912X.
Grow a beard, read this book (http://www.amazon.com/Site-Reliability-Engineering-Production-Systems/dp/149192912X) and apply for SRE jobs. Lots of them in Seattle, if my email inbox is any indicator.
I'm not joking about the beard.
You wanna be devops? Read how the best does it then take classes to answer everything you have questions about https://www.amazon.com/Site-Reliability-Engineering-Production-Systems/dp/149192912X
Google site reliability engineering wrote a book. Check it out.
Here's what I used to use:
https://www.amazon.com/gp/product/0521899435/ref=ox_sc_saved_title_2?smid=ATVPDKIKX0DER&amp;psc=1
https://www.amazon.com/gp/product/149192912X/ref=ox_sc_saved_title_1?smid=A26MBA1SHJSNWL&amp;psc=1
But here are some other good reads/materials:
http://www.aosabook.org/en/distsys.html
https://disco.ethz.ch/courses/podc_allstars/lecture/podc.pdf
I can't find the link I was thinking about, but here's a similar one: http://lms.uop.edu.jo/lms/pluginfile.php/2069/mod_resource/content/0/designing-distributed-systems-google-case-study.pdf
You don't need a school for this.
Low Level Programming Languages
For some Assembly
Software Reverse Engineering
Nostarch press/Wiley has books on this, plenty of defcon lectures. Watch 'Trolling with Math' as a way to defend against reverse engineering.
Operating System Theory
Also look up MIT classes 6.004 and 6.033 they cover all this in detail. Can find vids online of record lectures, open courseware assignments and lecture notes, ect.
Networking
Cellular and Mobile Communications
Discrete Math
Overview of Cyber Defense
Security Fundamental Principles (i.e., “First Principles”)
Above material covers this
Vulnerabilities
Legal
No idea
> For those who prefer video lectures, Skiena generously provides his online. We also really like Tim Roughgarden’s course, available from Stanford’s MOOC platform Lagunita, or on Coursera. Whether you prefer Skiena’s or Roughgarden’s lecture style will be a matter of personal preference.
>
> For practice, our preferred approach is for students to solve problems on Leetcode. These tend to be interesting problems with decent accompanying solutions and discussions. They also help you test progress against questions that are commonly used in technical interviews at the more competitive software companies. We suggest solving around 100 random leetcode problems as part of your studies.
>
> Finally, we strongly recommend How to Solve It as an excellent and unique guide to general problem solving; it’s as applicable to computer science as it is to mathematics.
>
>
>
> [The Algorithm Design Manual](https://teachyourselfcs.com//skiena.jpg) [How to Solve It](https://teachyourselfcs.com//polya.jpg)> I have only one method that I recommend extensively—it’s called think before you write.
>
> — Richard Hamming
>
>
>
> ### Mathematics for Computer Science
>
> In some ways, computer science is an overgrown branch of applied mathematics. While many software engineers try—and to varying degrees succeed—at ignoring this, we encourage you to embrace it with direct study. Doing so successfully will give you an enormous competitive advantage over those who don’t.
>
> The most relevant area of math for CS is broadly called “discrete mathematics”, where “discrete” is the opposite of “continuous” and is loosely a collection of interesting applied math topics outside of calculus. Given the vague definition, it’s not meaningful to try to cover the entire breadth of “discrete mathematics”. A more realistic goal is to build a working understanding of logic, combinatorics and probability, set theory, graph theory, and a little of the number theory informing cryptography. Linear algebra is an additional worthwhile area of study, given its importance in computer graphics and machine learning.
>
> Our suggested starting point for discrete mathematics is the set of lecture notes by László Lovász. Professor Lovász did a good job of making the content approachable and intuitive, so this serves as a better starting point than more formal texts.
>
> For a more advanced treatment, we suggest Mathematics for Computer Science, the book-length lecture notes for the MIT course of the same name. That course’s video lectures are also freely available, and are our recommended video lectures for discrete math.
>
> For linear algebra, we suggest starting with the Essence of linear algebra video series, followed by Gilbert Strang’s book and video lectures.
>
>
>
> > If people do not believe that mathematics is simple, it is only because they do not realize how complicated life is.
>
> — John von Neumann
>
>
>
> ### Operating Systems
>
> Operating System Concepts (the “Dinosaur book”) and Modern Operating Systems are the “classic” books on operating systems. Both have attracted criticism for their writing styles, and for being the 1000-page-long type of textbook that gets bits bolted onto it every few years to encourage purchasing of the “latest edition”.
>
> Operating Systems: Three Easy Pieces is a good alternative that’s freely available online. We particularly like the structure of the book and feel that the exercises are well worth doing.
>
> After OSTEP, we encourage you to explore the design decisions of specific operating systems, through “{OS name} Internals” style books such as Lion's commentary on Unix, The Design and Implementation of the FreeBSD Operating System, and Mac OS X Internals.
>
> A great way to consolidate your understanding of operating systems is to read the code of a small kernel and add features. A great choice is xv6, a port of Unix V6 to ANSI C and x86 maintained for a course at MIT. OSTEP has an appendix of potential xv6 labs full of great ideas for potential projects.
>
>
>
> [Operating Systems: Three Easy Pieces](https://teachyourselfcs.com//ostep.jpeg)
>
>
>
> ### Computer Networking
>
> Given that so much of software engineering is on web servers and clients, one of the most immediately valuable areas of computer science is computer networking. Our self-taught students who methodically study networking find that they finally understand terms, concepts and protocols they’d been surrounded by for years.
>
> Our favorite book on the topic is Computer Networking: A Top-Down Approach. The small projects and exercises in the book are well worth doing, and we particularly like the “Wireshark labs”, which they have generously provided online.
>
> For those who prefer video lectures, we suggest Stanford’s Introduction to Computer Networking course available on their MOOC platform Lagunita.
>
> The study of networking benefits more from projects than it does from small exercises. Some possible projects are: an HTTP server, a UDP-based chat app, a mini TCP stack, a proxy or load balancer, and a distributed hash table.
>
>
>
> > You can’t gaze in the crystal ball and see the future. What the Internet is going to be in the future is what society makes it.
>
> — Bob Kahn
>
> [Computer Networking: A Top-Down Approach](https://teachyourselfcs.com//top-down.jpg)
>
>
>
> ### Databases
>
> It takes more work to self-learn about database systems than it does with most other topics. It’s a relatively new (i.e. post 1970s) field of study with strong commercial incentives for ideas to stay behind closed doors. Additionally, many potentially excellent textbook authors have preferred to join or start companies instead.
>
> Given the circumstances, we encourage self-learners to generally avoid textbooks and start with the Spring 2015 recording of CS 186, Joe Hellerstein’s databases course at Berkeley, and to progress to reading papers after.
>
> One paper particularly worth mentioning for new students is “Architecture of a Database System”, which uniquely provides a high-level view of how relational database management systems (RDBMS) work. This will serve as a useful skeleton for further study.
>
> Readings in Database Systems, better known as the databases “Red Book”, is a collection of papers compiled and edited by Peter Bailis, Joe Hellerstein and Michael Stonebreaker. For those who have progressed beyond the level of the CS 186 content, the Red Book should be your next stop.
>
> If you insist on using an introductory textbook, we suggest Database Management Systems by Ramakrishnan and Gehrke. For more advanced students, Jim Gray’s classic Transaction Processing: Concepts and Techniques is worthwhile, but we don’t encourage using this as a first resource.
>
> (continues in next comment)
It's all about reading good source code. Books tell you how people think the world should be, or how they want to be. Source code shows you how it is. Learn C and get reading. Linux is a great platform because you have the source code for everything and it's written by people who care about the code (and know it will be looked at). Windows is a bad platform because you have the source code to nothing, and only have books to go from. There are of course good books, but the best ones tend to have lots of code in. As normal I'll push my favourites :
http://www.amazon.com/Lions-Commentary-Unix-John/dp/1573980137
(Old, but very very good and the grand daddy to SOO much)
http://www.amazon.com/Black-Art-Game-Programming-High-Speed/dp/1571690042
(Again old, but very good)
http://www.starstonesoftware.com/OpenGL/
(Modern accelerated crossplatform 3D)
http://lxr.linux.no/linux
(Good for those "how does my OS do...." reading)
http://source.winehq.org/
(Don't like the idea of Win32 as a common platform, but the code is good, and can help when MSDN fails you)
http://minnie.tuhs.org/UnixTree/Interdata_v6/
(pretty much the same version as Lion's Commentary, so useful online reference when the book isn't to hand)
Hope this helps someone. Might have helped a younger me.
Oh and python for kids! (And adults when it doesn't need to be C.)
(I'm not pushing C++ as I regard it as a handle with care language I'm not sure I'm for.....but it does feed me.)
A Bug Hunter's Diary: A Guided Tour Through the Wilds of Software Security https://www.amazon.com/dp/1593273851/ref=cm_sw_r_cp_apa_iWHXAb48X2078
So Tangled Web is a good book but it's not about exploitation in the sense it seems you're meaning. The Kernel Exploitation book is good but daunting if you don't have any exploit development experience. You may also consider A Bug Hunter's Diary by Tobias Klein
Grab a copy of the Intel IA-32 Assembly Reference http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html. I wouldn't recommend reading through this as a how-to but having a local copy to reference various unfamiliar instructions would be helpful.
Phrack articles are pretty useful too. Exploit-DB and packetstorm will be useful for finding working exploits for legacy bugs you may be practicing on.
Whatever language you're writing your exploits in (Perl/Python/Ruby) you'll probably want a reference for that.
A Common-Sense Guide to Data Structures and Algorithms: Level Up Your Core Programming Skills
I just started this but this book is very beginner friendly and includes examples in ruby, JavaScript, and python.
It was enjoyable, but very shallow/cursory/basic. I read it quickly & almost immediately forgot everything in it.
An alternative that's slightly more in-depth is "A Common Sense Guide to Data Structures and Algorithms" by Jay Wengrow. May also be helpful for 261.
It's still pretty visual & slightly cheaper, but w/more step-by-step walkthroughs & code examples. It's sort of in between Grokking & the CLRS algorithms book in complexity.
Get Grokking from the library if you can, read it quickly to get the basic ideas, and then look at the "real" textbook to see if it makes more sense.
I would recommend Wengrow's or Bhargava's to learn the basics in a more pleasant way and and then continue with others that dig deeper (Cormen, Sedgewick, etc.).
I'm just following that plan actually.
^((Sorry for my bad english))
I understand how you feel, honestly - as someone who did poorly in school, and I am somewhat dyscalculic, I really feel like I can relate!
The important thing for you, in my opinion, based on your explanation there, is to look for learning materials that suit you. Some people learn easily from really academic materials, some (like me) don't - and fortunately, there are lots of materials out there trying different approaches to teaching this kind of stuff. It gets easier as you go, as well - once the ball starts rolling you find it much easier to grasp future concepts. I got a massive 1300 page book called "An introduction to Algorithms" many years ago... Introduction my arse. It might as well have been alien language to me. But now, years later, I can actually understand its contents. It definitely was not an introduction (but it is a great book, both physically and literally).
A few recommendations for actual introductory books on these subjects:
"A Common-Sense Guide to Data Structures and Algorithms" by Jay Wengrow (2nd Edition coming 2020)
This book says the following in the opening chapter:
>"The problem with most resources on these subjects is that they're...well...obtuse. Most texts go heavy on the math jargon, and if you're not a mathematician, it's really difficult to grasp" . . . "Because of this, many people shy away from these concepts, feeling like they are simply not 'smart' enough to understand them."
It's not a perfect book, but it goes into a lot of basic data structures and explains them in a not-insane way. It helped me a lot! Understanding not just how they work, but why they are useful, is so helpful.
"Grokking Algorithms: An illustrated guide for Programmers and other curious people" by Aditya Y. Bhargava
A similar book, however, more algorithm and less data structure focused, and it goes into somewhat more depth, although usually the extra material is considered optional. The author here expresses a similar concern that books and learning materials on these concepts are often very hard to understand, and it need not be that way!
You can learn these things, you just need to find the right book/method that works for you! It can take some searching to find it. I know from experience!
Read the books, try to implement some of their concepts, and then try applying those things to real problems (i.e. from HackerRank or similar sites, try more than just HR). Read the book again. Repeat. You will understand a bit more each time. That was what worked for me, at least.
Start of with hackerrank if you want the basics. Then proceed to leetcode. Start with easy questions, then medium and hard.
Refer to these links:
Algorithms
Intro to Algorithms
Algorithms Design Manual
Algorithms are not an indicator of how good a programmer you are. Yes, algorithms are how you solve problems and it feels bad when you can't figure out the algorithm, but there's a million different algorithms that could potentially do the job, each with different constraints like time complexity, memory space taken during execution, initial order of the input data etc. If you're issue is not being able to solve a problem because you can't figure out what algorithms to use, you're actually already half way to the solution and further ahead than about 50% of my IT class. I'm in college right now and a lot of students don't even get to the point where they realize they need an algorithm to solve the problem, they just sit there and freeze and hope someone helps them or get a TA. While it's great to be able to solve algorithms on the fly, how about you not try to reinvent the wheel/rediscover a textbook's worth of human knowledge? There are literal textbooks which just contain different algorithms for different purposes: https://www.amazon.com/Algorithms-Algorithms_4-Robert-Sedgewick-ebook/dp/B004P8J1NA/ref=sr_1_3?keywords=algorithms&qid=1554225551&s=books&sr=1-3 (This one btw is used in a college CS course). Being able to memorize and/or recreate every algorithm in this textbook is not good programming (although I will say anyone who could recreate each algorithm independently is actually a genius). Being able to understand an issue and its constraints, and having a base of knowledge enough to either solve it immediately or help guide you to a new concept that would solve the problem is the ideal for being a programmer.
Take this challenge for example: https://www.codingame.com/training/medium/skynet-revolution-episode-1
I know I need a certain type of path-finding algorithm which always finds the shortest path for me to cut. I don't know what algorithm it is though since I've never learned about it. I could spend 10 hours rediscovering whatever algorithm is needed that was invented decades ago. Or I could be a smart, take the hint from the problem that a breadth first search is needed, and start learning about that to eventually solve the issue without trial and error. Over time, after completing multiple challenges, you'll accumulate the knowledge required to solve most problems as you are already familiar with all the algorithms required. And if you can't, that's just an opportunity to learn something new.
&#x200B;
Looking for this book: https://www.amazon.com/gp/product/B004P8J1NA/ref=as_li_qf_sp_asin_il_tl?ie=UTF8&tag=algs4-coursera-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=B004P8J1NA
&#x200B;
Will pay $5 via PayPal.
This book will explain how you go from a transistor to all of the basic components of a CPU: https://www.amazon.com/Digital-Design-RTL-VHDL-Verilog/dp/0470531088
This book will explain all kinds of advanced processor design and largely explain how the vast majority of modern processors work: https://www.amazon.com/Computer-Organization-Design-Fifth-Architecture/dp/0124077269/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1484689485&amp;sr=1-1&amp;keywords=computer+organization+and+design
There really aren't any prerequisites, you can just read those 2 books.
All I could recommend you are the texts I picked up in college. I haven't looked for any other resources. That being said:
http://www.amazon.com/Computer-Organization-Design-Fifth-Architecture/dp/0124077269
This text is really only useful after learning some discrete math, but is THE book to learn algorithms:
http://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
This one wasn't given to me in college, but at my first job. Really opened my eyes to OOD & software architecture:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
IMO the best book that gives an general overview of computer architecture is the book Computer Organization and Design by David A. Patterson and John L. Hennessy. That being said this is a difficult book. However, it goes over how memory hierarchy works to virtual memory to even showing you the data path of how instructions are executed. Is this is going to tell everything you need to do pen testing and so forth?. Not a chance.
It's a bit vague but yes, this is correct as an outline.
I just replied to what I think was another similar question of yours. I'd strongly suggest finding a copy of https://www.amazon.com/Computer-Organization-Design-MIPS-Architecture/dp/0124077269
It's the more mild textbook from two of the biggest people in the computer engineering world. They're the people that invented RISC.
It's a pricey book but for the sorts of questions you're after, any edition from the 3rd on to newer should be fine.
I had to look it up. It's the intro to computer architecture class.
Here's the textbook on Amazon without an affiliate link -- https://www.amazon.com/Computer-Organization-Design-MIPS-Architecture/dp/0124077269
Not because I think you're going to buy it on Amazon, but because you can "Look Inside" from that link.
It looks like they're still teaching from an old edition of that textbook. I would have converted to the RISC-V edition by now.
Sad.
That's a good textbook, though. The authors are legends (literally, look them up) in computer architecture. I actually prefer their other textbook ( -- A Quantitative Approach), but it's not suited for an intro class.
Have fun.
These are what I had. Different professors might use different books, obviously.
I didn't actually use or even buy the books for SoftEng and did fine. The other two classes relied heavily on problems from the book for homeworks.
We use vivado in school and they teach verilog. My impression is that VHDL is more of an industry standard, but I'm still a student so don't quote me on that. The way my university introduced digital logic was by having us start at logic gate level then use those modules to make state machines and last semester we made a MIPS processor.
Vivado (web pack should be free)
https://www.xilinx.com/products/design-tools/vivado.html
Here is the book we used for the processor
https://www.amazon.com/Computer-Organization-Design-Fifth-Architecture/dp/0124077269
Apparently the side bar needs additions, there is nothing there for MIPS.
edit Asked a colleague about online courses, Programmed Introduction to MIPS Assembly Language was recommended. Look well paced, and even has little quizzes you take to test your understanding as you go.
Books though, I can help with:
For high level theory and general architecture, the goto book is Computer Organization and Design by Patterson & Hennessy. It uses MIPS for the examples and the circuit diagrams throughout. I think its in it 5th edition. There are a few chapters at the end about where computer architecture is going and such (unrelated to MIPS) that changes between editions. University libraries will definitely have this, possibly even public one. This text is the standard for college-level computer science courses on computer architecture, and has been for something in the ballpark of 20 years.
For practical coding, I'd recommend (See MIPS Run by Dominic Sweetman](https://smile.amazon.com/Morgan-Kaufmann-Computer-Architecture-Design/dp/0120884216). It's in its 2nd edition, which I haven't read, so I don't know if it offers anything more than the first. The [first edition]
(https://smile.amazon.com/Morgan-Kaufmann-Computer-Architecture-Design/dp/1558604103) can be had used for next to nothing. It's especially good if you're writing real MIPS assembly on Linux as opposed to writing it on a simulator.
Computer Organization and Design or Structured Computer Organization
Sounds like you need to read a book on Computer Organization and Design. This book will teach you how to build a computer from basic logic gates. I can't recommend it highly enough.
It's verilog based but I like ciletti, mano, and patterson:
https://www.amazon.com/Advanced-Digital-Design-Verilog-HDL/dp/0136019285
https://www.amazon.com/Digital-Design-Introduction-Verilog-HDL/dp/0132774208
https://www.amazon.com/Computer-Organization-Design-Fifth-Architecture/dp/0124077269
https://www.amazon.com/dp/0124077269/ref=pd_luc_rh_ebxgy_01_01_t_img_lh?_encoding=UTF8&amp;psc=1
I just went through a project course and here were some good project ideas:
Conway's game of life with VGA/LEDPanel
Single Cycle CPU
2D convolution with Systolic Arrays (really cool)
The Assignments changed in difficulty a lot, some things were very nit picky things from the textbook, others were writing general Assembly programs.
the topics in general were what was difficult, writing Assembly itself wasn't that hard, but understanding how everything fits together with the diagrams was the difficult part.
we used Computer Organization and Design as our textbook, however the book is not designed very well and contains errors, it has a lot of information, but making sense of the information is what was difficult for me.
That's why I am trying to learn Digital Logic because I feel being grounded in that would make reading the diagrams and everything easier. Appendix B in that textbook, tries to cover digital logic, but it isn't explained very well and assumes you already know it when going through the actual material in the book.
https://www.amazon.com/Computer-Organization-Design-MIPS-Fifth/dp/0124077269
I believe this is the one. I had just rented it for the semester from Amazon, but they also have it in the bookstore. I don't doubt there's PDF's you could find of it online too.
That was a typo it's CE12. The past three quarters it has focused on digital logic structures, binary/hex math, basics of building a processor, and the MIPS assembly language. If you want to get a head start on the book pick up Computer Organization and Design.
CS101 will depend on the instructor. If you are assigned to Tantalo's class then you will be doing a mix of programming assignments and proof stuff. I'm not super familiar with the details but luckily, his materials are all posted on his course websites, just google UCSC CMPS 101 and find it. If on the other hand you are assigned to Sesh's class then (at least based on this last quarter) you won't be doing coding, you'll be doing very thorough proofs about algorithms. Both of these classes use CLRS which, if you're serious about CS, you'll probably want to have as a desk reference regardless.
Hey,
ECE212.
ECE241 - You learn C++ and OOP fundamentals in this course. We didn't have a textbook when I took it. Just online notes.
ECE241 - Stephen Brown is a prof at UofT and a great lecturer. I also still have this book if you are interested in buying from me!
ECE216 - Might still have this book if you're interested.
ECE221 - Professor Stickle probably will teach this course. Great lecturer but his tests/exams are notoriously hard.
ECE243 - Did not have a textbook when I took the course. Prof. Moshovos provided course notes online.
ECE297 - No textbook for this course. It's like a mini design project that lasts all semester where you have to build a concurrency based storage server in a team of 3. Picking a good team of programmers and technical writers is imperative.
Protip: Next time check TUSBE for textbook names and buying second-hand textbooks.
PS: Congrats on getting through 1st year, 2nd year will be tough.
This is what I use: http://www.amazon.com/Signals-Systems-2nd-Alan-Oppenheim/dp/0138147574
Oppenheim gives a really great explanation for the motivation and derivation behind the Laplace and Fourier Transforms in is book Signals and Systems.
I know he also has some lectures on MIT Open Courseware, but I haven't seen them. I've heard good things.
I was really happy to have read that book before my Diff Eq class. Because that text just threw the Laplace Transform at us like it was handed down from the gods.
I suggest you read some books that focus more on the general topic, IMO they provide more information and are more understandable.
Back when I was in university the first book about A/DS I read was "Algorithms and Data Structures" by Niklaus Wirth. I've looked it up now and it's freely distributed by the author in PDF format. http://people.inf.ethz.ch/wirth/
Then I read "Data Structures and Algorithms"
by Aho, Ullman and Hopcroft https://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237
and "Introduction to Algorithms" by Cormen, Leiserson, Rivest and Stein https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
Those books overlap in many parts, but it never hurts to re-read about a subject to better understand and memorize it. The first book is smaller in volume as compared to the other two, so it might be a good start, but judge for yourself - look at the tables of contents and compare what you find more appealing.
Princeton's class on Algorithms and Data Structures
JavaWorld's Data Structures and Algorithms in Java tutorial
And my old standby: Aho, Hopcroft, and Ullman's Data Structures and Algorithms
If you don't have time/want to get results quickly then you could look into using Navmeshes. Otherwise you need to get your hands dirty with some algorithms.
Most people use A*, DBF, or Dijkstra. There are tons of easy to find resources on them.
A good book that has a few chapters dedicated to graph traversal is Data Structures and Algorithms
Sidenote, how are you using raycasting with the zombies? If you simply want them to not run into shit and don't really care about how smart they are, a simple solution would be to get the radius of the collider around the zombies, check if another collider has collided with it, if it has then make the zombie rotate x degrees and begin moving again. OnCollisionEnter should be sufficient enough. Just make sure the prefab zombie has a collider on it and each wall has a collider.
> Data Structures and Algorithms
http://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237
Is this the book you're referring to?
I've been focusing on C# for the past year when I can. Currently "developing" an archiving tool for certain files that I am hoping to use as a resume piece. Trying to show off things like MVVM, IoC/DP, async/await, cloud storage integration and the new .net stuff. Metro style UI, maybe.
I know that C++ is in demand, but I thought I'd have an easier time starting with C#, which I also see a lot of firms looking for. Based on the networking I've done, C#, Javascript, or C++ would all have been good places to start. I just want to get my foot in the door somewhere. Getting past the resume glance inspection is my biggest hurdle.
Data Structures and Algorithms is what I used in my class... not so easy to read but a ton of sample code that is easy to understand. I would recommend checking it out at a library before buying it, though... my class was fairly 50/50 on who liked it and who didn't.
most recommended book in my courses is "Modern Operating Systems" or "Computer Networks" from Andrew Tannenbaum or http://www.amazon.com/Data-Structures-Algorithms-Alfred-Aho/dp/0201000237
For information architecture, information display books i can recommend:
Information Visualization: Design For Interaction by Robert Spence
The Humane Interface by Jeff Raskin
The Humane Interface by the late Jef Raskin. It's amazing.
hummm
tried that buff/dodge/buff , doesn't work for me
plus since I have several buff to activate (4 at the very least, then optional luckbringer, pleiad, etc..) i simply cannot have them all in shortcuts..
pressing second buff on a specific frame is imho incompatible while in a fight which is the whole point of the mystic art. (again imho)
queueing the buffs was an awesome way to get them all applied in an efficient way and this is broken.
broken because you get the sound fx but not the buff, or the shortcuts square icon animates but the buff is not applied , etc etc.
the GUI is inconsistent.
I have to wait, then check if buff is activated. this is just not acceptable .
if i turn the steering wheel to the right, i expect the car to turn right, not to have to maybe turn the wheel some more.. basic interface design..
these devs should read Jef Raskin
I read that this change in the behavior was in response to the fact that you would sometime spend two buff when pressing the button only once. well the quick fix is badly in so many ways...
wrong decision : force a delay
wrong implementation : the gui response and the sound fx response is not dependant on buff activating but on activation button being pressed
how i would have done it:
have an extra settings : allow reapplying of buff: yes no combat / out of combat
yes => you can activate a buff ontop of itself, renewing its timer
no => if a buff is active, you cannot re-apply it.
with condition in combat out of combat.
> PS: jef raskin is the true father of the macintoch
If you like this kind of stuff, I highly recommend "Hacker's Delight". It's a fantastic book that goes orders of magnitude beyond anything discussed here.
http://www.amazon.com/Hackers-Delight-Henry-S-Warren/dp/0201914654/
"More focused" is the key point for me. I have a different opinion what that means, that's all.
See here for the following quote:
> The following subjects would be off-limits: Technology, devices, software, operating systems;
For me, operating systems are relevant to coding: they define the framework that I must navigate in order to get my code to do what it is supposed to. But I can find my OS-related programming content elsewhere, I don't need to have it present in /r/coding. But I would rather exclude too much than allow too much in - noise is distracting, and simplicity stimulates focus. If people really miss something, it will find its way in.
Regardless, I can recognize a losing battle - the idea of code reviews seems to have many supporters and few opponents, so it will happen anyway if someone wants to risk and endure not-so-constructive criticism, puns and potential fame on TheDailyWTF.
I think the whole idea will be short-lived. The comment threads will provide some helpful remarks (e.g. read Code Complete, Beautiful Books, or other books, learn about various algorithms and their computational complexity to figure out better approaches, etc.). The comments will become redundant after a while, and then people will realize that they are doing somebody's homework, and that learning good style is largely a self-study, and can't be passed on in a couple of sentences. And we'll have a new rule for "no newbie code reviews here".
But I've been proven wrong by Reddit many times before, so I won't bet on my version of events. So, who's gonna be the first one to submit code for a review?
Hacker's Delight
http://www.amazon.com/gp/product/0201914654/sr=8-1/qid=1144182215/ref=pd_bbs_1/002-3707800-4554451?%5Fencoding=UTF8
is another great resource
All of the suggested items are great. But as they are mainly comp sci, I'll suggest something diving a bit deeper to the EE end.
Compsci is easier to learn usually on your own, so this is a book made for comp sci people who want to start diving into lower level stuff.
Check this out.
He used a specific CPU design that already has a compiler for it. So you will essentially load "code" as a set of minecraft blocks which represent the code. You can do ANYTHING with the CPU. It just crunches numbers, does maths and shits out results, same as your CPU.
A CPU is at once a simple thing and a horribly complex thing. A CPU has a set of instructions. This set of instructions and some other parameters of how you interact with the CPU represent your CPU Architecture. Instructions are the lowest level unit a programmer works with the CPU. An instruction is simple "load a number into a register" (register is just a really small piece of memory, just big enough for a 32bit or 64 bit number). Then you might say something like, "multiply stuff in these two registers" and then the result goes to some other register. You might have an instruction that says "move data from here to this location in memory".
You have I/O devices.. "ports" that you poke and prod with the CPU that perform input and output and allow humans to interact with the devices.. but none of that really matters. When you can actually SEE the CPU like in minecraft you can watch what is happening without the need for a lot of I/O.
He used the CPU architecture described in: http://www.amazon.com/Elements-Computing-Systems-Building-Principles/dp/026214087X this book. Since that CPU architecture has a compiler for it that is how it will run code. He will "compile" the programs, translate that "machine code" to "minecraft block machine code" and then the CPU will be put into a state to execute that program :)
(Oh, that book is pretty awesome). I dug this up: http://en.kioskea.net/contents/pc/processeur.php3 which gives you a rough overview of things. Honestly ANYONE that can do basic arithmetic can sit down and understand how a CPU works in about 8-10 hours. You just have to "accept" many things just work at first and that CPU can do all of this. A simple CPU is so easy. x86 and x86-64 are not so simple, yet I think assembly is fairly easy to understand for any programmer. Oh well. :)
Then you can deconstruct the basics of logic gates and building simple circuits to make your own CPU, which is what this guy did.
These are insightful questions and the answers are less obvious that it might seem. There are subtleties that for various reasons I can't and won't cover here, and the best advice I can give you is to read about the subject(s). The second best advice I can give you is to search Google like mad, because there's a lot of stuff out there and I don't have time to find other books.
> but setters should be protected, for extensibility
How often do you extend your classes? If it's often, it's probably too much -- favour composition ("has-a") over inheritance ("is-a"). I declare all my classes
finalto start with and I rarely have to change that. More, your private members are the only ones you have complete control over -- as soon as something isprotecteda deriving class can use it, and then the member is effectively part of the public API after all. For this reason,protectedis nearly as bad aspublic. This is one of the things Scott Meyers talks about.> Furthermore, do I even need setters if my class is going to be the only thing setting its variables?!
Automatic code generation is one of the least helpful things IDEs have given us and, I contend, a direct source of much shitty code. Make no setter or getter until it is absolutely needed, and provide neither for
publicfields (that will cause confusion).> Should I ever be setting object variables outside the class?!
"It depends". There are valid reasons for it, and of course I can't think of any off the top of my head. What you should absolutely avoid is the ability to construct a
Foowithout aBarwhenFoocannot work withoutBar. In this case, it's a constructor dependency, and aFoo::setBar()implies thatFoo'sBarinstance can be in an invalid state.> but as far as I know the repository pattern only really achieved popularity after the blue book came out and that's the one DDD technical pattern that really seems to have been widely accepted.
Are you talking about Smalltalk-80 the Language and it's Implementation? Or this book on Domain Driven Design?
No problem! I've been reading this one, and it's an awesome resource: http://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
Aside from that, Domain-driven design gets occasionally discussed over at http://laracasts.com, and there's a google group specifically for using DDD in php: https://groups.google.com/forum/#!forum/dddinphp
> That's exactly a multi-agent simulation.
Well yeah, that was kind of my point. At least in biology, this isn't unusual.
> For most processes this is a too low level representation to be
> useful.
I find very useful, and I've modeled pretty much all business processes that I've implemented this way. Eric Evan's excellent book Domain Driven Design describes some very useful ways to reason about business processes, in effect, as multi-agent simulations (if you call an agent an entity in DDD terms).
Grady Booch
http://www.amazon.com/gp/aw/d/020189551X/ref=pd_aw_sbs_14_2?ie=UTF8&amp;dpID=51-uo4HUPCL&amp;dpSrc=sims&amp;preST=_AC_UL100_SR100%2C100_&amp;refRID=110KGH6M22KWAJHKWZ5F
Eric Evans
http://www.amazon.com/Domain-Driven-Design-Tackling--Software/dp/0321125215
Martin Fowler
http://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420
> I don't know what the fuck you're actually advocating.
Try to get some more experience, kid. Especially with things like Dependency Inversion and Domain Driven Design. Then maybe you'll understand.
> Put adaptors on all the things so you don't depend on them, but
> you're not passing interfaces to everything.
You don't create such fine grained interfaces that wrap around a single library in particular. That would make the adapter nothing more than a call translator. You would end up with a bunch of interfaces around every little library you need, and that would be dumb.
The whole point is that your code represents some business functionality, and the architecture should be dependent on the rules of the business. At some point you'll need help with some aspect of the business or another. You write an interface to describe that need. The adapter simply fulfills that need.
The adapter will probably have functionality of its own, and depending on the system, perhaps not trivial. But that functionality is isolated from the rest of the system. It can be replaced at some cost that is isolated.
J2EE application servers do a lot of work, and the EJBs leveraged that capability (like clustering, distributed transactions, etc.). We had to find replacements for those capabilities. The replacement wasn't trivial. But the application itself could care less about most of that. So the risk to the application was substantially reduced.
Which allowed us to focus on specific, isolated areas and didn't risk the entire application.
> Then you talk about the one time that architecture saved you
> time and not the five hundred times it didn't.
Prove it.
> If you're putting all libraries in an adaptor then you're interfacing
> all the things and your constructors will be huge or nested.
The number of interfaces depends on how fine grained your abstractions are. You don't want your abstractions to be too fine grained, or you'll have a ton of dependencies. If you end up creating 15 interfaces in your constructor, that means you have way too many dependencies. That's a definite code smell and a definite sign you need to rethink your abstractions.
> If you're transforming your data
And what data would that be? For the most part, we are talking about parameters.
> you've got application logic in your adaptor which means
> replacing it is not low risk.
Not application logic, which is another domain. But logic related to the domain of the library. Because that logic is isolated, and independent of the business rules of the application, it is a lot easier to replace.
> If you're encapsulating your errors you've broken your stack
> trace.
Nope. The error is simply being recast into the application's domain. That is if it needs to be recast into the applications domain at all. The adapter can do much of the error handling itself, if that error handling falls into its domain.
> Separating your business logic from your presentation layer has
> nothing to do with being dependent on libraries.
It has everything to do with it. The separation of presentation layer from business logic is small potatoes compared to what I'm talking about. The Domain Driven Design book has a great section about the Anti-Corruption Layer, which describes how to protect an applications architecture from the architecture of other libraries and systems.
Libraries that represent an entire domain separate from the business domain shouldn't affect its architecture. If the library is substantial enough that it could effect the architecture of the application and more importantly is a risk to the application, it belongs to a different domain and the domains should be separated to reduce risk. We're not talking apache-commons-lang which just does string manipulation.
Domain Driven Design
Pragmatic Programmer
I would recommend looking into Domain Driven Design (DDD). A book a lot of people recommend is Domain Driven Design by Eric Evans but sometimes it's hard to translate the examples in the book to something you can apply in JavaScript. However you can probably find articles about DDD in JavaScript if you google for it.
I’m fairly certain (sorry if I’m wrong) he means the book by Eric Evans:
https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
Vocês acham o Cormen melhor que o do Sedgewick? Eu to usando o dele e to achando excelente
(https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=pd_sbs_14_t_1?_encoding=UTF8&amp;psc=1&amp;refRID=MH6S5JKZVVS8V4W5SD9D)
It isn't always necessary to take some introductory courses. At my school, students coming in with a background in computing could skip CS101 and head right into CS102.
To be fair, not all schools carry identical curriculums, so OP should reach out to some professors to gauge whether he can skip an introductory course.
OP, if you have a good understanding of Java, you might want to check out Algorithms by Robert Sedgewick and Kevin Wayne. It's a great introduction to computer science and was one of the textbooks in my CS102 class. Sedgwick and Wayne also have a website which has a number of great resources.
The companion site for Sedgewick has Java implementations for everything in the book.
I used the 2nd edition of this book called Data Structures and the Java Collections Framework. At the time it was one of the most up-to-date books on Java 1.5 and generics. The book is very accessible for students, and probably one of the better technical books I've read in my entire academic career.
However, if I was to learn data structures from scratch again, I'll probably would go with Algorithms by Sedgewick. I've heard nothing but good things about the book, and don't let the name fool you. It actually focuses on the implementation of data structures or so I heard.
I'm in the same boat, I've been reading https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ and I can definitely say it's the most insightful learning I have done thus far
https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X
this one?
For a good algorithms and data structures textbook take a look at: Algorithms 4th Ed. by Sedgewick and Wayne (https://www.amazon.ca/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=pd_lpo_sbs_14_img_2?_encoding=UTF8&amp;psc=1&amp;refRID=Y10M1BMYGCSJCJJN2GJT) or Introduction to Algorithms 3rd Ed. by Cormen, Leiserson, Rivest, and Stein (https://www.amazon.ca/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844).
Fuck the CLRS book. You are not going to just pick that up and learn anything meaningful in a summer. Get a book that is commonly used for a course in DS&A. If you know/ are interested in java, this book is quite good: https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/ref=sr_1_2?ie=UTF8&amp;qid=1495589242&amp;sr=8-2&amp;keywords=algorithms
Ovo su dve "standardne" knjige:
Introduction to Algorithms (Cormen, Leiserson, Rivest, Stein)
Algorithms (Sedgewick)
Lično, ja volim ovu (od drugog autora gore): Algorithms in C++
Dodatno, Knuth je pre neku godinu izašao u PDF-u i verujem da bi mogao da ga nađeš po Internetu, ali iskreno - danas je to nešto gde ćeš se najviše diviti tipografiji, i ako si baš baš baš jako matematički inkliniran dokazima (). Za praktične potrebe 2017. godine bilo šta od ona dva gore navedena je bolje.
() Kome nije dosta matematike u Knuthu - Concrete Mathematics: A Foundation for Computer Science. Opet, možeš provesti udoban radni vek bez da znaš išta od toga, što ne znači da ne treba da čitaš ako nisi radoznao. Svakako ćeš biti u prednosti u odnosu na onog ko nije.
https://www.amazon.com/dp/032157351X/
https://www.amazon.com/dp/0262033844/
C# is not a popular language with academics who tend to write cryptic Java and C/C++ for a living, so good luck finding a reference written by someone credible.
CompSci covers a wide range of subjects, many of which won't be that relevant to you. When I was at Uni my classes covered:
This list isn't comprehensive, but covers most of the main points. For your job, you can happily ignore most of that core.
I think you'll want to focus on with the highest priority:
Warning: Algorithms is a heavy and dry book. It might not be a good recommendation for a beginner to be honest.
As you're interested in Data Science, you're already off to a good start with R and Matlab. Python is fine but has some issues that don't make it ideal for large-scale data processing. The good news is that once you've got the hang of Python, you can learn another language much easier. I think it's worth noting that R is quite obtuse in my experience, so if you get your head around that you're doing quite well.
But I digress. You're also going to want to learn about data structures, networked systems and databases, especially if you want to work with "Big Data". I think thought that your best starting place here is learning how to code. With that under your belt along with your math degree, everything else should be easy enough to learn on a case-by-case basis.
Source: Masters & PhD in CompSci subjects. Good luck, and feel free to PM me if you're interested in a mentor for this. With a better understanding of your position, I could probably help pare down what you need to study to more specific subjects.
PS: Assuming you're at Uni, your library should have both books I have suggested.
CLR is a great book, but like all text books, it's not cheap. If you're looking for used books, and find that you can get Sedgewick for a better price, then that's an equally good book to learn from.
I've always preferred to learn by videos such as from Udemy or Udacity, but if books are your preference I suggest Algorithms(4th Edition).
It's pretty intensive at times but it also has a course that goes along with it which is pretty fantastic.
You can pick a book on Algorithms by Sedgewick, which is quite a standard recommendation for algorithms book these days and benefit both programming exercise and problem solving at the same time.
Sure thing. I used the following two books for studying how to implement them and not just study the theory:
A book I have recently been recommended was "How to create a mind." Seems to have some bias, but has interesting takes on the subject.
I won't deny I'm fairly early on in my degree myself, but if you want what I've been using as supplementary material, here they are.
If you're looking for some code books, I suggest the big red book. That's pretty standard as the go-to Algorithms book. Fairly dry, but it the 4th edition has some good explanations of nice and efficient algorithms - plus, clean code.
Finally depending on your preferred language (I'm a C++ person myself) this book might have some relevance.
Introduction to the Design and Analysis of Algorithms, by Levitin, was used at my university and none of us cared for that book and I don't recommend it.
I'm not familiar with #1, but I do recommend:
im not sure what you do with CIS, but im guessing sysadmin type stuff? if that doesnt interest you and the job listings dont either, look into a straight BS in CS degree. you can probably transfer some credits. check out an algorithms book like this one (google it for the pdf) http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X or this one http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844 and if they interest you check out CS. take some courses for free on codecademy and see if web programming interests you. theres a million ways to go online and check out other cs related avenues that might be more for you. explore cs classes on your campus after reading the course descriptions, audit a class for free. sign up and then leave during drop add. see how things sound. check things out. good luck!
The one book that every programmer should read is Code Complete. It goes over all stages of development in a high level overview that applies to any project.
I would then move onto Algorithms by Sedgewick and Wayne. I tried reading Introduction to Algorithms because it was strongly suggested to me, but it goes into higher level math really quick. I haven't taken calculus since high school and never took any higher level math classes in college, so I got lost after about page 30.
After that, I would just look for a book dedicated to design patterns in the main language you work with. There are some overlapping patterns between languages, but it's best to be practical about what you learn.
I think this is a pretty standard book used in universities: http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X
Using it right now in my CS masters class and it's pretty helpful.
You can easily find it free just searching for the pdf online.
It goes over hash tables, trees, stacks, queues, sorting, and more.
Bitcoin mining programs are pretty advanced pieces of software, especially due to the rise of ASICs and other esoteric hardware that must be supported. You might want to consider an easier project for the time being.
Fundamentally, you need to have a good grasp on data structures before you can really get going with Merkle trees and cryptocurrency mining in general.
Here are some free resources to get started
If you want to consider grabbing a book, Algorithms (4th ed) is generally regarded as a decent book to get started on thinking with and using algorithms and data structures.
edit: depending on the time you have, you may also want to consider reading this on set theory. It tends to make later algorithms a bit more clear as a lot of it draws from set theory.
Given some of the 2-star reviews for the book on Amazon, I'm not surprised at the quality: https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/product-reviews/032157351X/ref=cm_cr_arp_d_hist_2?ie=UTF8&filterByStar=two_star&reviewerType=all_reviews&pageNumber=1#reviews-filter-bar
Try Algorithms by Robert Sedgewick and Kevin Wayne. I haven't read the book itself (I have used it for reference once or twice) but I have taken a Coursera course on algorithms given by professor Sedgewick, and the clarity with which he lays the material out is really notable. There is something great about learning how to implement red-black trees from the guy who invented red-black trees. (Oh, by the way, that course is free and starts again on August 7th. The course and book together would complement each other very well, I think.)
Algorithms, Part I on Coursera (presented by Princeton) begins in 5 days. The professors recommend their own book, Algorithms, 4th Edition
Amazon link
Implementing DDD from Vernon is a must-read after Evans:
https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577
It is not exactly focused on microservices. However, the DDD conception "Bounded context" is the key point for microservices.
Well of course. The new hot thing needs to clear the space for itself: DDD, CQRS, Event Sourcing. This approach cannot be done Agile way because it requires top-down architecture design.
New books need to be sold. New consultants need to sell their services.
Endless circle of life.
I would recommend the Art of Electronics (or the ARRL Handbook) if you are looking for more of a reference style text. Very thorough, but not something you would want to read front to back.
Assuming you have your circuits basics down, a good text to really start learning how to design circuits would be Microelectronic Circuits by Sedra and Smith which is your undergrad text on introductory analog/digital circuits. This one you can definitely read front to back (but it's big). And then if you really want to get into the thick of things, you could read Analysis and Design of Analog Integrated Circuits AKA Grey and Meyer which is your advanced undergrad/graduate text on analog circuits. There are many alternatives to these texts, but these ones are basically bibles.
This one.
Amazing book, in my opinion.
What's your background? If you've had some experience with the basics, then my recommendation for a good comprehensive overview of analog circuits would be Gray & Meyer:
http://www.amazon.com/Analysis-Design-Analog-Integrated-Circuits/dp/0470245999/ref=sr_1_1?ie=UTF8&amp;qid=1346983358&amp;sr=8-1&amp;keywords=grey+and+meyer
If you're interested in learning, I highly recommend picking up a copy of Essential System Administration from O'Reilly: http://www.amazon.com/Essential-System-Administration-Third-Frisch/dp/0596003439
It's a bit dated, but very much relevant. Definitely worth a read.
Head first design patterns
This might also help
this book was a good starting point for me. https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
If you want to understand why objects and interfaces are useful, I'd recommend reading Head First Design Patterns. It is truly the first resource I came across that made me grasp why objects and interfaces have a useful purpose.
I started to write an example for ELI5, but I decided that the first two chapters of that book would be a great example. It even includes ducks. :P
Came here, all excited to mention the Pragmatic Programmer but it's already at the top of the list. My upvote can't even help it get higher.
Then I came for the Mythical Man-Month, but you got me there too.
FinalSin, you're killing me here :)
That said, there is one more on my list that isn't covered here:
Head First Design Patterns taught me more about software design than any other book ever, arguably comparing to Pragmatic Programmer.
I would focus more on deciding what you want to make. When you can make something that works, you're a programmer. When your code isn't brittle, is well commented/documented, is "clean" and other devs can understand and work with it, you're a good programmer.
So pick something you want to create and make it: a website, a simple program, a game, etc.
How to go about it? Once you have that thing you want to make, break it down into bite size tasks and start tackling them one at a time. First, you'll need to figure out what language and libraries you need (or want) to use. Then set up your dev environment and get a "Hello World" example to work. Then just start building piece by piece. Once it works, make it work better (i.e. refactor it).
I use a bunch of resources to be a better programmer:
I hope that helps.
> Because I did not know how to instantiate objects the only way I knew hot to get a variable from another class was to make it static.
>
Oh aahahah. Sorry, was being stupid. ANd my OOP isnt too great, is this the book?
If you are also new to OO programming in general, I would get these books and work on the examples. They will provide you with an excellent foundation for programming in Java.
http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124/ref=sr_1_1?ie=UTF8&amp;s=books&amp;qid=1251928378&amp;sr=8-1
http://www.amazon.com/Thinking-Java-4th-Bruce-Eckel/dp/0131872486/ref=pd_sim_b_54
http://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683/ref=sr_1_1?ie=UTF8&amp;s=books&amp;qid=1251928591&amp;sr=1-1
Head First Design Patterns is what I've used. It takes the very dry and detailed approach of the GoF book others have mentioned and makes it much more approachable and human friendly. They have a whole section at the beginning about their teaching approach in the book. There's a lot of examples, diagrams, conversations between participants. They take a conversational tone which is much easier to understand and read. As a student I cite the GoF but I learn from the Head First book.
Design Patterns is called "The Bible," also called the "GoF Patterns" aka "Gang of Four"
Some people like Head First Design Patterns as an introduction (it has better code examples), but if you end up wanting something more information dense/rich then try the GoF.
Judging by that image, I think it's a page from Head First Design Patterns, which really is an excellent book on the subject, it is so easy to read and provides very clear examples for everything
You can just google for it to find a PDF version
>So what did you do? Anyone else have a formal CS education and feel like they came out of it with nothing?
I graduated in 2006 and I've been doing web development professionally for almost four years now. Until about two weeks ago, I felt like I could have skipped my entire five years at school because most of the stuff just doesn't apply to web development since it's so far abstracted from the hardware. I was reading my algorithms book on the toilet the other day when I realized that I learned a shitton at school and it gave me an incredible advantage over the guy who learned web development on the fly. It helps to go back and re-read things after you have a context to put it into so you can apply what the theory to what you've learned.
It took me a long time to start getting designs down. You have to make a lot of mistakes before you can learn from them. It's as simple as that. Don't get discouraged. If you haven't read Head First Design Patterns, buy that book right now and read it cover to cover. I had read design pattern catalogs, but none of them conveyed the 'why' as well as HFDP did. They don't have abstract, car has wheels, Ford is a car. They have real code examples and they show you why you should favor composition rather than inheritance. Why you should follow the law of Demeter.
I've entertained the notion of starting over several times. Don't quit, and don't get discouraged. If you ever get to the point where you think you've learned all you need to learn and you're writing code that can't be improved, start over.
I've heard good things about Design Patterns: Elements of Reusable Object-Oriented Software and Head First Design Patterns. Haven't read either yet myself, but they're on my todo list.
See these resources
> Like a bunch of spaghetti
That might not all be your fault, I have no idea how good the codebase is! ;)
Two resource recommendations for you:
One other thing I encourage you to do is to ask questions of the senior devs on the team. Try to find someone who you get along with and might be able to serve as an informal mentor. I know it is difficult to say "I don't know", but it is a lot better than floundering with a problem for a week. Good luck!
Head First Design Patterns
Like anything else it's a tool and should be used at your discretion. Design patterns have their own pros and cons. But the book will at the very least give you some useful building blocks for organizing your code.
It goes through the why as well as the how.
Head First Design Patterns is a great place to start.
Many of the "why" questions are more general than just Java. I'd suggest a book on design patterns ([Head First Design Patterns](Head First Design Patterns: A Brain-Friendly Guide https://www.amazon.com/dp/0596007124/) is pretty good and accessible for a beginner) or object oriented programming in general.
Learning the theory and patterns of polymorphism, composition, etc will certainly help when trying to understand why languages implement certain features, and will also make you much more capable of using those features in the wild.
This is a pretty nice one for picking up design patterns:
http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124
Heres a book; but those expansions were bad. Lorewise, I thought still bad but if you like to read.
Care to elaborate on what you mean by functional program framework?
Are you talking about doing functional programming in C? I think there is a book on that. I think it's this one: http://www.amazon.com/Functional-C-International-Computer-Science/dp/0201419505/ - I'm not so sure though.
Are you talking about building framework/programs that are functional (as in robust, secure, ...)? If that is the case, then there is an interesting book named "C Interfaces and Implementations" going through several kinds of modules you might want to implement in C, and going through how you'd elaborate an interface and an implementation for them => http://www.amazon.com/Interfaces-Implementations-Techniques-Creating-Reusable/dp/0201498413/. This book covers the sort of thing that I believe you should be studying after learning the overall language syntax and semantics, how to combine features of C to solve not so trivial algorithmic problems, and so forth. In summary, it talks about modules design (both interfaces and implementations) in C.
There are more books here, like those listed in here http://www.iso-9899.info/wiki/Books. You can also check some more learning resources here http://www.iso-9899.info/wiki/Usenet and here http://www.iso-9899.info/wiki/Web_resources.
Still on my second interpretation of your functional program framework (because idk much about the first one besides that book "Functional C"), there are tons of very complicated systems built in C, like operating systems, server software, and so forth. And for many of them, there were books written. Here are some software for which you can find books on their design and implementation:
There are probably more, but those are the one which came to mind.
I took the same two courses, as well as EE123 (digital signal processing), which had a very good text: http://www.amazon.com/Discrete-Time-Signal-Processing-2nd-Prentice-Hall/dp/0137549202. Another good one is http://www.amazon.com/Signals-Systems-Prentice-Hall-Signal-Processing/dp/0138147574/ref=sr_1_1?ie=UTF8&amp;s=books&amp;qid=1240638404&amp;sr=1-1 , which was an optional text for EE120 when I took it (much better than the Lee & Varaiya text IMO).
Another book to add to the list:
Data Structures and Algorithms (Aho, Hopcroft, Ullman)
It's very easy to follow, the examples are in pascal.
If you have the CLRS book, with that you are ok. This is much shorter.
This book is excellent. Yes, the code samples are in ancient languages, but the explanations are clear and you're learning it from masters of the craft who know it thoroughly and explain it thoroughly.
Breaking away from the Rails (or in my case Django & SQLAlchemy) mindset of the model is both the business model and the persistence model can be hard to do.
However, why not this? -- This might not be good scala, I mostly tool around in it, you'd probably want status as a private attribute:
abstract class TaskStatus()
case class TaskCompleted() extends TaskStatus()
case class TaskPending() extends TaskStatus()
class Task(var status: TaskStatus) {
def isCompleted: Boolean = status match {
case TaskCompleted() => true
case => false
}
def markCompleted(): Unit = status = TaskCompleted()
}
Then Task is a regular object with no ties to a repository or service.
new Task(TaskCompleted()).isCompleted // true
new Task(TaskPending()).isCompleted // false
val t = new Task(TaskPending())
t.isCompleted // false
t.markCompleted()
t.isCompleted // true
This makes Task an entity it has business logic and state that persists from session to session (this other state is probably a title, who its assigned to, and an ID as a persistence allowance, but I've omitted these for brevity).
You can then stuff these tasks into a data store (pick your poison on how you do that) and reconstitute them from that data store -- essentially that's what a repository is: take in some entities, shove them into a data store; take in a query, pull some entities out of the data store.
With that in mind, your
TaskService.isTaskCompletedcan be a simple wrapper around a repository query that pulls that one task out and doesTask#isCompletedon it (note you'll want to guard against unfound Tasks):class TaskService(val repo: TaskRepo) {
def isTaskComplete(id: Int) {
repo.findId(id).isComplete
}
}
Expanding this out to your TaskAssignments, your task now holds a reference to many TaskAssignments that probably have an
isCompletedon them as well. In that case,Task#isCompletedcan end up just being `tasks.forAll(.isCompleted).<br /> <br /> Still no reference to a repository. The trick here is thatTaskis now an aggregate. When you ask the repository "Will you find me task 12345?" It not only pulls the literalTask` out of the data store, but also all the parts of the Task as well. So you get the Task and the TaskAssignment objects.You might want to check out Domain Driven Design which helped cement these sorts of ideas in my head.
Been reading that and this
honest question: are you trolling?
I have no idea, how you could've read the text, that you've just quoted, and still think that flash storage somehow works "like paper"
let me break it down for you, so you can understand........ELI5:
flash storage are maaaaany different small disks
small disks can write veeeery fast
but small disks also get broken, after writing a looooot of times
hurts
cheap disks get broken faaaaast
expensive disks get broken sloooow
but, there is good news:
if one disk dies, others are still there to work
yaaay
but they are not as fast as before :'-(
And now ELI17 (which is probably your actual age):
You've just quoted, that there are different types of flash storages, that have different PE cycles (according to the manufacturer)....so you understand that there is a quality difference in flash storage
I think your problem is, that you think 100000 PE cycles lasts for 1000 years or something.....
First of all: the flash storage that you buy from the store (in any shape or form) isn't the same as device manufacturers use as components for their devices. Especially when we're talking about embedded systems (you think they put a Samsung SSD inside their smartphones? They don't!) manufacturers want to save money, and therefore usually go for the rock bottom cheapest option they can get. (just like they use the shittiest reject fruit to put into jelly)
And secondly: A PE cycle doesn't mean that something gets deleted off of the disk, whenever you uninstall an app or delete a music file. An operating system that works entirely on a flash storage is constantly writing and deleting files! Every time you leave an app in Android, (and the onStop() method of the activity is called), the app gets cached on the storage to free up ram (DRAM)
therefore you have hundreds or even thousands of delete operations every day, especially with TRIM enabled.
-----
Don't be a retard. Either fully read the links I've provided, or just stop arguing about something you know absolutely nothing about. Don't just Ctrl+F through an article to find signs for things that vaguely sound like they'd make your argument. And stop claiming that flash storage is like paper. I'm usually a big fan of analogies, but I have no idea where you pulled this one out - especially because it doesn't make any sense
if you're actually interested in this subject matter.....I purchased this book, when I was studying computer science:
http://www.amazon.com/Computer-Organization-Design-Fifth-Edition/dp/0124077269/ref=dp_ob_title_bk (this is the newest edition, I have an older one)
it's a pretty good point of reference for understanding how computer hardware works. it is very dry though
To be honest I found this book terrible, pages and pages of mathematical equations. Great if you're want to really understand the mathematical underpinnings of algorithms, but hardly a primer to practical stuff.
I found this book more approachable http://www.amazon.co.uk/Algorithms-Robert-Sedgewick/dp/032157351X/ref=tmm_hrd_title_0?ie=UTF8&amp;qid=1412426976&amp;sr=1-1
then yes, you are writing bad code. Good instincts!
read this ... a few times.