Best computer vision & graphics books according to redditors
We found 427 Reddit comments discussing the best computer vision & graphics books. We ranked the 39 resulting products by number of redditors who mentioned them. Here are the top 20.
We found 427 Reddit comments discussing the best computer vision & graphics books. We ranked the 39 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
Refactoring: Improving the design of existing code
Design Patterns
Working Effectively with legacy code
Clean Code
How to be a programmer
Then there are language specific books which are really good. I think if you read the above, slowly over time, you'll be in a great place. Don't think you need to read them all before you start.
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:
My bad.
In Object Oriented Programming (OOP), there are lots of design patterns that end up getting repeated all over the place. You might have run in to the factory pattern, or perhaps the builder pattern?
If you can understand and notice these patterns, it means you can re-use old code more effectively, because code to handle a pattern in one place is probably very similar to code to handle a pattern in another.
In addition, if you're discussing a problem with somebody, it means you can refer to the patterns by name as a sort of shorthand notation for "put it together like this". Saying "use a decorator" is a lot quicker and easier than describing what exactly "a decorator" is from scratch every time.
The "Gang of Four" are four Computer Scientists who were among the first few to notice that these patterns kept popping up, and wrote a pretty well known book describing about 20 of the most common ones.
In this specific instance, the builder pattern would probably have proved useful. Rather than having a single, monolithic constructor, you create a separate "builder" class.
Character chararacter = new Character(xx, yy, life, kpph, kpyl, kvin, krak, kgr, kptgr, kbb, havepph, havepyl, havevin, haverak, haveya, isevented, x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, IE)
Can become
Character character = Character.builder()
.life(life)
.initialCoordinates(x1, y1)
...
.build()
This is waaayyy more readable (especially if you're assigning values as arguments, rather than named values. If you ever called createFrom(...) with a string of numbers, it'd be very difficult to work out which number was what), and a lot easier to lay out properly. It also means you can gather arguments for creation gradually over time rather than all at once.
Also looking more closely, and as /u/PM_ME_YOUR_HIGHFIVE pointed out, they're not actually using objects at all, which would be a good place to start.
Some book recommendations:
Others that are great and related but not as "necessary" as the above three:
Unrelated to "better code" but still great:
Creo que mucha gente se confunde ser autodidacta con hacer algun cursito de como hacer una web y darle con eso.
Para llegar a cierto nivel, tenes que aprender computer science, teoria y trabajar en cosas que te permitan aplicar esa teoria.
Tenes que saber ver un algoritmo y poder calcular la complejidad, tenes que entender que son las patrones de diseño y cuando conviene aplicar tal o cual.
Tenes que entender como funciona OOP, pero tambien tenes que aprender algun lenguaje funcional, te va a hacer un programador más rico.
Tenes que entender de Unit Testing, automated testing, Integration testing.
Los dos libros que más me ayudaron cuando empecé en computer science son :
https://www.amazon.es/Algorithm-Design-Manual-Steven-Skiena/dp/1848000693
y
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Y ir codeando mientras vas leyendo y aplicando las cosas es fundamental.
Me parece que la diferencia entre ser autodidacta es que no tenés esa vara minima que te da la facultad, asi que depende de vos que tan crack queres ser y si estas dispuesto a poner el laburo y a aprender cosas constantemente.
La información esta en internet o Amazon, no hay ningún secreto.
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.
I think your major problem here is that you want the "why not"s instead of the "why"s. A good programmer can look at a chunk of code and determine "why" the programmer is doing certain things. These pre-extising code blocks that people refer to are given because you should be able to read through it and interpret what's going on and why. The questions you most likely ask at the "interpreting" stage isn't "why" but instead "why that way and not this way?"
Really, when it comes down to it, the answer as to that question for a lot of things in engine programming (or just programming in general) is that it's what the lead designer or lead programmer thought was the best idea.
For instance: How do you want to store your array of tiles? As integers representing tile indexes in a tile set? As separate Tile class instances in a vector array containing vector arrays of Tile instances? As a hashmap indexed using characters to grab a tile? etc. There's a million ways to handle each and every part of an engine, it all comes down to what design patterns and what theories you think are the best for what you need your engine to do.
I suggest reading up on some of the design patterns in here (actual link in the sidebar) and here. They're a great way to start understanding the multitudes of ways of handling different ideas in your engine! Reading up on pre-existing theory or seeing pre-existing pseudo-code is fine and dandy, but sometimes you have to reinvent the wheel. Sometimes, for the most part you can follow a lot of design patterns that already exist.
P.S. For a great tutorial on loading tile maps and working with them in your game, lazyfoo's got you covered (it's in C++ but can easily be adapted for other languages) Here
Having done an MEng at Oxford where I dabbled in ML, the 3 key texts that came up as references in a lot of lectures were these:
Pattern Recognition and Machine Learning (Information Science and Statistics) (Information Science and Statistics) https://www.amazon.co.uk/dp/0387310738/ref=cm_sw_r_cp_apa_i_TZGnDb24TFV9M
Machine Learning: A Probabilistic Perspective (Adaptive Computation and Machine Learning Series) https://www.amazon.co.uk/dp/0262018020/ref=cm_sw_r_cp_apa_i_g1GnDb5VTRRP9
(Pretty sure Murphy was one of our lecturers actually?)
Bayesian Reasoning and Machine Learning https://www.amazon.co.uk/dp/0521518148/ref=cm_sw_r_cp_apa_i_81GnDbV7YQ2WJ
There were ofc others, and plenty of other sources and references too, but you can't go buying dozens of text books, not least cuz they would repeat the same things.
If you need some general maths reading too then pretty much all the useful (non specialist) maths we used for 4 years is all in this:
Advanced Engineering Mathematics https://www.amazon.co.uk/dp/0470646136/ref=cm_sw_r_cp_apa_i_B5GnDbNST8HZR
I admire your dogged adherence to being wrong in every particular. It takes a special brand of stubborn contrarianism to quote someone's badly edited notes as a primary source and then followup by a claim that this is best possible research.
However, outside in the real world, Alan Kay writes extensively and authoritatively here and in his numerous contributions on Hacker News quite aside from publications spanning decades.
And an awful lot of people agree with his definition. The introduction of the classic Design Patterns defines objects as an encapsulated package that only responds to messages. People who teach OO programming readily quote Mr Kay's definition. The Ruby programming language is fundamentally based upon it, and before you shout "but Ruby has classes" note that Ruby classes are actually themselves objects, for which the
newmessage happens to do something particular by convention. And so on; the point being that Alan Kay's definition is super influential, which is why the idea that Erlang is the most object-oriented language is not a new proposition.Even though this seems to be just aggregating some Stack Overflow answers into blogspam, I'll bite.
> Two lines of code is too many
If you're seriously going to complain about one extra line of code in a method, I don't see this ending well.
> If it's not native, it's not really programming
Semantics. Even if you don't call it programming, you'd damn well better know those things if you want to use them. SQL, Java, and any other VM-based language may not qualify as "programming" by this definition, but they're still damn useful.
> The "while" construct should be removed from all programming languages. (In favor of "Repeat...Until")
Semantics again. There is no functional difference between the two, and I would argue that while is actually preferable since it puts the looping condition right there on the same line, instead of having to skip to the end of the block to find out if you even entered the block in the first place.
> Copy/pasting is not an anti-pattern.
No, it's not, and it's been proven. I'm having a hard time finding the peer-reviewed study on copy/paste programming right now, but basically, it's been shown to save a lot of time as long as you're using it properly.
Where the hatred for it comes in is that, like GOTO, if you use it too often, you'll probably end up using it wrong.
> Developing on .NET is not programming, it's just stitching together other people's code
A reiteration of his 2nd point, but honestly, a huge amount of working as a professional programmer -- hell, almost the definition of working in a team -- is stitching together other people's code. There's nothing wrong with that, and it's hardly controversial.
> The use of try/catch exception handling is worse than the use of simple return codes and associated common messaging structures to ferry useful error messages.
This has been getting debated a lot in go-lang circles, but the general consensus seems to be that unless you're working in an embedded environment (or some other highly-constrained environment), you're probably better off with try/catch.
> Test constantly
Test-Driven Development is something that I personally agree with, and truthfully has become a very popular practice among Rails people. I don't see how that would qualify it as being controversial.
That said, certain studies have shown evidence that TDD is not as effective as many seem to believe.
> Object Oriented Programming is absolutely the worst thing that's ever happened to the field of software engineering.
I've heard this claim semi-often. It seems to mostly come from people having worked with languages that claim to be OO but constantly make exceptions to the rules, like Java, C++, or Python. In fact, the author specifically calls out Java.
Try Smalltalk or Ruby and you'll come to see that OOP done right is actually quite wonderful.
> C (or C++) should be the first programming language
Debatable, but certainly not controversial by any stretch of the imagination.
> Classes should fit on the screen.
How big is your screen? I can fit any class definition on a 64" monitor.
Some classes simply must be large. It is an unavoidable fact that certain things are simply more complex to model than others. This point isn't controversial, it's just asinine.
> Making invisible characters syntactically significant in python was a bad idea
This again? Is it really a controversial opinion if it's been something non-Python programmers have been whining about for decades? Because as far as I can tell, people whine about it for about the first five minutes of Python coding, and then give up because they would've been indenting anyway.
It can cause bugs when transferring code between computers, I'll give them that. Otherwise, it's Python demanding good formatting, something that you should be demanding from everyone on your team anyways.
My main regret with Python is that I haven't found a good tool that auto-formats everything (a la "gofmt").
But otherwise, Python's indentation requirements are so in line with common indentation in almost every programming language that proper indentation comes naturally to more or less everyone. In how many programming languages that you regularly use do you not format your conditional, looping, class/method, or exception blocks?
> Singletons are not evil
It's not controversial to agree with Design Patterns. That book is more or less the undisputed truth on the subject, and it thinks the Singleton pattern is fine and dandy.
I'm sort of in the same boat as you, except with an aero and physics background rather than EE. My approach has been pretty similar to yours--I found the textbooks used by my alma mater, compared to texts recommended by MIT OCW and some other universities, looked at a few lists of recommended texts, and looked through similar questions on Reddit. I found most areas have multiple good texts, and also spent some time deciding which ones looked more applicable to me. That said, I'm admittedly someone who rather enjoys and learns well from textbooks compared to lectures, and that's not the case for everyone.
Here's what I gathered. If any more knowledgeable CS guys have suggestions/corrections, please let me know.
Full disclosure: I haven't actually read more than the preface of any of those books. Software engineering topics are more directly applicable to me than CS topics right now, so here are some that I've actually started reading:
You have a long journey ahead of you, but here goes :D
Beginner
C++ Primer: One of the better introductory books.
The C++ Standard Template Library: A Tutorial and Reference: Goes over the standard template library in fantastic detail, a must if you're going to be spending a lot of time writing C++.
The C++ Programming Language: Now that you have a good idea of how C++ is used, it's time to go over it again. TCPPL is written by the language's creator and is intended as an introductory book for experienced programmers. That said I think it's best read once you're already comfortable with the language so that you can full appreciate his nuggets of wisdom.
Intermediate
Modern C++ Design: Covers how to write reusable C++ code and common design patterns. You can definitely have started game programming by the time you read this book, however it's definitely something you should have on your reading list.
C++ Templates: Touches on some similar material as Modern C++ Design, but will help you get to grips with C++ Template programming and how to write reusable code.
Effective C++: Practical advise about C++ do's and dont's. Again, this isn't mandatory knowledge for gamedev, but it's advice is definitely invaluable.
Design Patterns: Teaches you commonly used design patterns. Especially useful if you're working as part of a team as it gives you a common set of names for design patterns.
Advanced
C++ Concurrency in Action: Don't be put off by the fact I've put this as an "advanced" topic, it's more that you will get more benefit out of knowing the other subjects first. Concurrency in C++11 is pretty easy and this book is a fantastic guide for learning how its done.
Graphics Programming
OpenGL: A surprisingly well written specification in that it's pretty easy to understand! While it's probably not the best resource for learning OpenGL, it's definitely worth looking at. [edit: Mix it in with Open.gl and arcsynthesis's tutorials for practical examples and you're off to a good start!]
OpenGL Superbible: The OpenGL superbible is one of the best ways to learn modern OpenGL. Sadly this isn't saying much, in fact the only other book appears to be the "Orange Book", however my sources indicate that is terrible. So you're just going to have suck it up and learn from the OGL Superbible![edit: in retrospect, just stick to free tutorials I've linked above. You'll learn more from them, and be less confused by what is 3rd party code supplied by the book. Substitute the "rendering" techniques you would learn from a 3d book with a good 3d math book and realtime rendering (links below)]Essential Mathematics for Game Programmers or 3D Math Primer for Graphics and Game Development: 3D programming involves a lot of math, these books cover topics that OpenGL/DirectX books tend to rush over.
Realtime Rendering: A graphics library independent explanation of a number of modern graphical techniques, very useful with teaching you inventive ways to use your newly found 3d graphical talents!
I was going to ask what range of water effects you want (waves, small ripples, splashes and droplets, topology change). Small ripples can be handled with much easier techniques than big splashes. On refreshing the thread, though, it sounds like you want behavior on the more difficult end of things. So...
Have you written a fluid simulator before: smoke, water, anything? If not, you've got your work cut out for you. Robert Bridson's Fluid Simulation for Computer Graphics is an excellent reference, but I'll give you paper links that cover most of the relevant material.
I believe LiquidSketch uses a FLIP solver. FLIP is a hybrid particle/grid method, and Animating Sand as a Fluid is the standard reference for it in graphics. SPH is of course also an option, but tends to have more stability problems, and you'll probably want a pressure step more along the lines of PCISPH or Position-Based Fluids. I'd probably recommend going with FLIP -- it's a particle-based approach, so you can capture fine features more cheaply than with a purely grid-based method, but it is much less finicky than SPH.
If you start reading the FLIP paper and feel lost, for background you might start with Real-Time Fluid Dynamics for Games, Stable Fluids, and Visual Simulation of Smoke. Practical Animation of Liquids might also be useful if you want to know about level sets and other basic issues in grid-based liquid simulation.
You could also consider using a pre-existing solver. Mantaflow is a research-oriented solver, but its code is reasonably clear and modular, especially compared to other open source fluid simulators. It's written primarily for Eulerian (grid-based) fluids, but it also has some FLIP support. You will need some fluid simulation knowledge to use it effectively. Others might know of off-the-shelf solvers that are easier to use, more flexible, or faster.
The "bible" is "The Grammar of Graphics" by Leland Wilkinson. (link to amazon). The "gg" of ggplot2 stands for grammar of graphics.
Then we go into other books, resources that help with actually showing visualizations:
Then we can look at the "Table of Elements of Data Visualization":
Then, we can look at some blogs to help you see what works and doesn't work:
Finally, some blog posts about other people in data visualization that you can learn from:
Design Patterns by the gang of four. It is the essence of designing software architecture. It describes very common designs that have been tested time and time again, however it is broad and you have to specify your requirements but it is an amazing starting point.
(ps it actually is similar to design problems in civil architecture identified by Christopher Alexander. A Pattern Language (1977) & A Timeless Way of Building(1979).)
It really opens doors to how you should approach and choose the correct design. It's not language specific. The book however does have C++ examples
I would recommend reading Design Patterns: Elements of Reusable Object-Oriented Software. That book will give you the majority of design knowledge you would gain at this point in your career from college.
The resource seems very extensive such that it should suffice you plenty to be a good software engineer. I hope you don't get exhausted from it. I understand that some people can "hack" the technical interview process by memorizing a plethora of computer science and software engineering knowledge, but I hope you pay great attention to the important theoretical topics.
If you want a list of books to read over the summer to build a strong computer science and software engineering foundation, then I recommend to read the following:
The general theme of this list of books is to teach a hierarchy of abstract solutions, techniques, patterns, heuristics, and advice which can be applied to all fields in software engineering to solve a wide variety of problems. I believe a great software engineer should never be blocked by the availability of tools. Tools come and go, so I hope software engineers have strong problem solving skills, trained in computer science theory, to be the person who can create the next big tools to solve their problems. Nonetheless, a software engineer should not reinvent the wheel by recreating solutions to well-solved problems, but I think a great software engineer can be the person to invent the wheel when problems are not well-solved by the industry.
P.S. It's also a lot of fun being able to create the tools everyone uses; I had a lot of fun by implementing Promises and Futures for a programming language or writing my own implementation of Cassandra, a distributed database.
> What is/are the benefits of ggplot compared to to matplotlib/pylab?
From my understanding, ggplot2 is an R package that aims to create graphics that follow the design principles from a book called "grammar of graphics". Also, they're pretty as hell with basically no effort required. This is an attempt to mimic that package in native Python.
Matplotlib is more powerful, and more customizable, but the default settings are ugly and sometimes almost illegible.
Super minor nitpick:
R Studio is the development environment.
Ris the language.Presumably you want to become well versed in the latter rather than the former. It's an easy mistake to make though, since the two are so intertwined for most people as to become almost indistinguishable.
More to your point though:
Before learning anything, it's a good idea to ask yourself why you want to learn it, and what you hope to be able to do with it. Now, you mentioned two things,
Both of these are relatively simple, and if you have even the most rudimentary understanding of
R, you could learn to do in a couple of minutes.So, my question to you would be, in using
Ris your goal to get quick, simple answers to straightforward questions OR are you ultimately looking to be able to do much more complicated tasks? This isn't a judgemental question, not everyone needs to aspire to become anRgod, just needing something quick and dirty is perfectly okay.If the things you mentioned are more or less the extent of your needs, I'd suggest just googling what you need to do at the time and pick up what you need, more or less, through osmosis.
However, if you have designs on being able to do amazingly complicated things, if you want to push
Rto its fullest, you'll need a more structured approach.One thing you absolutely must understand is
Ris a package based language. What this means for you is that beyond the numerous ways you can do any task in any language, people have written countless* packages which contain all sorts of handy functions to do just about anything you could conceivably want to do.>* Okay, it's not really countless, there are (as of this writing 12,620 packages on CRAN and 1,560 additional packages on bioconductor. There are bunches more of unofficial ones scattered about GitHub and others privately maintained, but you get the point, there's lots of them.
So, for anything you want to do, you can approach it in one of two, very broad, ways:
R.When you are starting out, I think it's very important to get a good handle on Base
R.I would start out with basically any introductory
Rbook. Search on Amazon and just find one you like.Personally, I can recommend Using R for Introductory Statistics by John Verzani. It isn't for everyone, but if you're truly a beginner to both
Rand statistics more generally, it's a good reference text.After that it's, up to you. Where you want to take it. For me, the pantheon of
Rgods* I would pay tribute to are these four:>*I'm sure every single person on that list would balk at being called a "god," but they'd be lying.
It's no mistake that 3/4 of them work for R Studio.
The god of tidiness.
Hadley must be a complete neat-freak because he's the driving force behind the
tidyverse,>The tidyverse is an opinionated collection of R packages designed for data science. All packages share an underlying design philosophy, grammar, and data structures.
Once you branch out of base
R, thetidyverseshould be your first destination. It's not quite a new language unto itself, more like a very sophisticated dialect of the language you already know. Once you can speak "tidy," you can still communicate with the "base" speaking plebs, you just won't be able to imagine every wanting to.*>* this is not exactly true, and might come across as gross and elitist, but the
tidyparadigm really is substantially better. If you were designing a completely new language to do statistical competing, from scratch, today, the language would probably feel a lot like thetidyverse.Anyway, any book by Hadley Wickham is gold, and they're all available online for free. But R for Data Science is a good first step into a larger world.
The god of speed.
I imagine Dirk is not a patient man. He's very active on forums, basically every meaningful response on stackexchange for an Rcpp related question is his (or his collaborator, lesser-god Romain Francois), but sometimes his responses can seem a little... terse?
Now,
Ris notoriously slow. It's much maligned for this, usually fairly, sometimes not.Much of the perceived slowness can be mitigated in base
Rby learning the suite ofapplyfunctions which are vectorized. That is they take a multivalued variable (a vector, matrix, or list) and they apply the same function to each element. Its typically much, much faster than using a for-loop. However, you can't always get away from needing a for-loop, and sometimes your loop will need to run thousands (or millions) of times. That's where theRcpppackage which Dirk maintains comes into play.It is an interface between
RandC++, there's not much to say about the package itself. You'll need to learn at least some rudimentaryC++to make use of it, but simply breaking out a computationally intensive for-loop into anRcppfunction can yield a huge improvement in run times. 10x-100x (or more) depending on how well (or poorly) optimized yourRandC++code is. There's some weirdness involved (like you can't call anRcppfunction in a parallel apply function (separate package) unless yourRcppfunction is loaded as part of a package, so for maximum benefit you'll need to learn how to write your own packages - praise be to Hadley).Rcppincludes some semantic "sugar" which allows you to write some things inC++more like you would inR, but that's yet a third thing to learn.Also
Rcpp, much like thetidyverseis more an ecosystem of interconnected packages than a single package.The god of art.
Base
Rplots are ugly as sin. They just are, no one should use them ever, for any reason.*>*Exaggeration.
That said, Winston's*
ggplot2is a revelation and a revolution in how graphics are created and presented.>* Yes, technically
ggplot2is also Hadley's and is part of thetidyverse, but Winston literally wrote the book on it. Okay, okay, Hadley technically created the package and has written books about it, I just find Chang's book more fitting to my needs.The "gg" in
ggplot2stands for "grammer of graphics", a common structure for describing the components of a visualization in a concise way.Learning
ggplot2will take you a long way toward being able to make beautiful graphical visualizations.The god of sharing.
After you've learned all of the above. You can wrangle your messy data into something tidy and manageable, you can work on it cleanly and power through massive computations, and you can create stunning images from your data, it all means nothing if you're the only one who sees it.
This is where Yihui shines. He is the maintainer for the
knitrpackage, and the author of Dynamic Documents with R and knitr. This will allow you to turn all of your work into PDFs or web pages to share with the world.It's super easy to get started with, much more complicated to master, but definitely worth it.
To use it effectively, you'll need to learn
rmarkdownalso by Yihui. You'll also want to start dabbling withLaTeX(if your not proficient already) and to truly bend documents to your whim you'll need to learn to tinker withYAML.Closing remarks.
It's a lot to master. Few ever will. Not everyone will agree on everything I've said, but I think the park to true mastery looks something like that.
Best of luck!
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!
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.
Hi PizzaPartify,
I believe that different companies/teams will place emphasis on different skills. When I was helping to hire software engineers for EA's motion capture studio, I liked to see candidates who showed a strong aptitude for engineering code to be maintainable. For me, this meant a familiarity with design patterns and software development processes (like Test Driven Development or Extreme Programming). In my department, much of our code was in C++ and Python. However, other departments would use languages like Java, C# or ActionScript - depending on the project.
It would be helpful to know what role you are applying to.
To answer your specific questions:
Regardless of the language you're working in, I would also recommend Design Patterns by the gang of four (http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612).
A game-specific recommendation is Game Engine Architecture by Jason Gregory (http://www.amazon.ca/Game-Engine-Architecture-Jason-Gregory/dp/1568814135). It doesn't matter if you intend to write an engine or not, it is immensely helpful to understand how they work.
I own all of the Game Programming Gems books but use them more as a reference library. The books above will be more helpful right now.
I hope that helps.
From what I understand they're a way to structure your code to solve specific problems. An example would be a combination of the Factory pattern and the Component pattern as a way to use data driven design to create "things" in your world (I have enemy Bob, Bob.txt/Bob.xml/Bob.whatever has all the information to create Bob. The "factory reads in this info, and then handles creating the entity and components.)
If you'd like to learn more there's the gang of 4 book Design Patterns: Elements of Reusable Object-Oriented Software, and for a focus on design patterns in games I liked gameprogrammingpatterns.com
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/
The book that allowed me to do this is the legendary "Gang of Four" Design Patterns book. Code examples are in C++ and it was written a while ago, but is still recommended as a fantastic resource for learning how to design software well.
There is also the SOLID principles, for object oriented design.
Beginner and Novice are the same thing. It sounds like you're trying to transition of Beginner to Intermediate.
You really should stop trying to write your own framework for the moment, and start using a mature framework. Good frameworks aren't trivial to write, and generally require an expert level of knowledge to write well.
The thing with a framework is that it helps remove you from a lot of boilerplate code - that is, common code everyone would normally need for any give web project. The easiest way for you to bridge the gap is to begin using and understanding code that is better than yours. Don't reinvent the wheel until you understand how to make a better wheel.
Design patterns are everywhere in good code. The trick is to recognize when a design pattern is being used, and to understand why it's being used. In order to help with this, it's commonly recommended to read Design Patterns: Elements of Reusable Object-Oriented Software. This is a book every programmer should own regardless of the language they use.
The amount of planning you have to do scales with the complexity of the project.
Professors drill the importance of planning, documentation and unit testing into students because it is extremely important and once you start your career if you're a poor planner it's going to come back to haunt you.
However, when you're working on a simple project that's not intended for public release you don't have to go overboard with docs unless you just want to practice.
My own process usually starts with me jotting down an idea; I find that writing it out helps me to get a better grasp on the overall feasibility.
Once I'm satisfied that I actually have something I can implement I'll diagram the flow of the application, and maybe do some wire-frames.
I usually find that this is enough of a launching pad for a simple personal project.
Professional projects are a different ballgame, because as I said, the amount of planning you have to do scales with the complexity and size of the project. It's in the professional environment that all of the things your professors are teaching you will become really important.
So, to answer what I think was your question,
>So how does one end up with 20 classes connected with each other perfectly and a build file that set everything up working flawlessly with unit test methods that check every aspect of the application?
This comes about more in the implementation phase than the planning phase. I've heard it said that in war "no plan survives contact with the enemy" and you'll find this to be true in software development as well. Even when you plan really well you'll sometimes have to go back to the drawing board and come up with a new plan, but that's just part of the process.
Some books that I recommend on the topic are Hackers and Painters - Paul Grahm and I think every software dev should have a copy of Design Patterns
The former is a collection of essays that might give you some useful perspective on the process of writing software.
The latter is more of a reference book, but it's helpful to become familiar with the patterns covered in the book so that you don't find yourself re-inventing the wheel every time you begin a new project.
As for the other part of your question (apologies for addressing them out of order)
>My new "bottleneck" writing code is the structure. I end up having huge classes with way to many public methods. I might as well just write a script with everything in one file. Almost anyway.. I try to write OO, but I often get lazy and just end up with not very elegant systems I would say.
Don't be lazy, because as you're already seeing, it comes back to bite you in the ass.
As you're writing your code you have to be mindful of the complexity of the project as it grows around you, and you have to periodically take a step back and look at what you've created, and re-organize it. This kind of goes back to what I was saying earlier about no plan surviving enemy contact.
So when you find yourself creating a new class that you hadn't thought about, be mindful of where you put it.
Should you create a new file (yes, of course you should), new folder?
Do you have a bunch of similar classes doing the same thing? Should they inherit from one another?
Be especially mindful of copy and pasting from one are of your code to another, generally speaking if you're doing this you should probably be writing a function, or using inheritance.
It's up to you as the developer to make sure your project is organized, and now-a-days it's really easy to learn how to best organize code by looking through other peoples projects on github, so there's really no excuse for it.
Hope that helps, good luck.
> Felt pretty good about myself.. until I got to the algorithm section.
This is VERY normal. These are hard math concepts that take everyone a little bit to get used to. The only way you will learn these concepts is by implementing them, over and over and over and over and over.
> I would say I was getting stuck probably about half the time and would turn to read-search-ask method.
If this were not the case, then there would be no need to learn. I am a web developer and I look up the most inane shit on a daily basis because it is something that I either have never used/implemented or something I rarely use/implement (my big one here is PHP's array functions, I can never remember if the array comes before the callback or not with
array_map()but I remember that it is the exact opposite ofarray_filter()andarray_reduce()). Embrace this, build your Google-fu because you will always need it.> A lot of times I was missing some small operator (code error) or somewhat minor step in the thought process, other times I would be lost entirely. Basically I wasn't thinking about how to implement my code well enough, imo.
This is 100% normal. Have you ever heard of a code review? This is where other developers review your code before it goes live. The point of this is that you cannot be 100% perfect with your code, maybe you forgot a semicolon or maybe your code is tough to read, that is what the code review process is like. I write code in iterations to make sure that I never 'get in too deep' and the fear of removing code sets in, each of these phases I go through a mini code review to see what is working at what isn't. I ALWAYS find some half-baked logic in my first few iterations before I really get into it and over the last couple years I find that I need fewer and fewer iterations and that I am able to get a better 'big picture.'
Don't be afraid to scrap some code and go back at it, this is your education and only you know when you understand the material. I have a bajillion abandoned side projects and so does every developer that I know.
Advice
Links
I did FCC up through the frontend section, I started my web dev career path in 2014 and picked up FCC in mid 2015 right before getting a job in web development. The most important part of FCC is that you are coding, getting practice and making mistakes, TONS of mistakes. Just keep it up, don't get burned out and remember that it is about your education, not how many challenges you complete. Code and read and read code.
http://pragprog.com/the-pragmatic-programmer/
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.amazon.com/Hitchhikers-Guide-Galaxy-Douglas-Adams/dp/0345391802
Indeed I can. =D
Knowing a giant list of programming languages is really overrated. Instead, focus on learning new programming concepts.
Sometimes that can mean learning a new language, but not always. Some examples:
And regarding your concern of it being harder to learn new languages later, you'll only really have that problem when learning a vastly different language (such as Scheme when compared to your C#). Once you know one language in the same "family", a lot of knowledge carries over.
C and C++ are pretty different nowadays depending on your standard. "Game engine" is a pretty generic descriptor, because you can build game engines in a lot of different ways depending on your needs for the genre and how all-encompassing your engine needs to be, so I'm going to ask you a few questions about specifics in regards to your experience which might help to flesh out where you can start your search.
Hope this helps.
You probably already have, but if not, definitely read Design Patterns, which is old but a classic. I'd also highly recommend the Pragmatic Programmer.
EDIT: I just want to say, that I also fully support alienangel2's answer. I wanted to recommend a couple good books to get you on "the path", but ultimately, the best thing by far is to find a job that grows you. For some people, the best way to do that is to work at a super small startup, where everything you're building is from scratch. For others (like me), the best way is to work at a company with tons of really smart people who have already built great software, and learning from them and the choices they've made (and why). And if you still feel like you're regressing since school, maybe that's the answer: go back to school (i.e. get a Master's or PhD)!
These are all good points.
With respect to Design Patterns, I feel that the holy grail is Design Patterns - Elements of Reusable Object-Oriented Software by Gamma et al.
One of the things we can do to make our lives harder in software engineering is muddle terminology. It adds needless friction to our job if when you say "flernb" you're referring to a widget but when I use say it, I'm talking about a whozit.
In low level code, we're pretty good about sticking to the first term that was coined for something. If you have a series of objects, each with a reference to the next, you'll probably call it a "linked list", just like I would.
But when it comes to higher-level architecture and design, names get a lot messier. Fortunately, some dudes wrote a book that tries to be the beginning of a taxonomy for architecture. Ultimately, the names they pick are arbitrary, but if we all agree to stick to them, then they become concretely useful.
What the author describes here is not a proxy. A proxy is a local object that represents a distant one, usually on another machine or process. It's not a very common part outside of distributed systems.
The author created an adapter.
Here's a rough outline, from high level to low(ish):
Extra Credit
That will get you started but there's tons more. The best thing you can do is write code and read code and be patient.
For the first two I think OP means:
https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
I'd also recommend:
https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master-dp-020161622X/dp/020161622X
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&ie=UTF8&qid=1333263240&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.
Books
Stuff to watch
Blogs
Other resources
From wikipedia, and I highly recommend this book as reference material.
No expert, but I have been enjoying reading through Programming Computer Vision with Python. It starts you off with how to manipulate images.
There's more than a single design pattern for applications. Recommended reading: https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented-ebook/dp/B000SEIBB8
Those who want more detailed info on these should check the Design Patterns book by GOF
Link:
https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8
Two things: The coursework from my CS degree, and reading books about software engineering.
I've spoken in other places about the former, and for the latter, I recommend The Pragmatic Programmer, Code Complete, and Design Patterns: Elements of Reusable Object-Oriented Software
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.
They seem a like reasonable starting point I think. Repetition is the mother of mastery, the more books the better (in addition to applying what is learned).
Since Mosh is calling out learning fundamentals as important to becoming a good C# developers, I would personally also recommend some general (non C# specific books) too for who are starting out in software development:
There's a ton more, but those are a few that stood out to me. Essentially the more the merrier in my opinion - books, courses, videos, tutorials, and so on. The books I'm recommending here focus on adopting the developer mindset and being successful at it. That's part of the puzzle.
The other part is understanding the technical details including the programming language and frameworks you intend to use.
And finally, for learning about C#, I do highly recommend Mosh's videos/courses (some are free on YouTube, others available on Udemy). He's got a unique ability to explain things clearly and simply in a way that beginners can pick up quickly.
What I'd do is check out his free content first, and if you agree his style is ideal for learning, an investment in one of his courses is well worth it since he'll cover a lot more breadth and depth on each of the topics and they're organized into a super consumable package rather than scouring the internet for various topics.
MVC is just a paradigm. Implementations differ from language to language, and some languages have better support than others, but yeah, just a paradigm.
Look into Design Patterns by the (in)famous "Gang of Four" for more information about this.
I will say this -- most experience I have with C# backends leads to great usage of databinding between model and view regardless of application platform (WPF, Windows Forms, even some ASP.NET). And I'm pretty impressed with the support of other design structures that C# and Visual Studio offer with the help of NuGet (looking at you, Angular).
Perhaps offtopic but... Some books you should read regardless of CompSci branch
Introduction to Algorithms by CLRS. Used in almost every algorithms class I've heard of, and a great reference book. It's about 1300 pages, so don't try to read straight through it.
C Programming Language by K&R. This is a C programmer's Bible.
Design Patterns by the Gang of Four
This is a little more of a topic book, but The Art of UNIX Programming by Raymond.
These are all either pretty common, or almost essential. You'll probably see these in your curriculum anyway, and you should. These are a good cornerstone.
Small employment gaps are no big deal. Over six months people may ask, but it's all in how you answer. I'm not sure why you feel like you're unmarketable having worked in the industry for two years, but do know a lot of the postings - especially junior postings - are inflated. I've seen one that asked for three years of experience with Visual Studio 2019. If you're halfway there, shoot your shot.
As a junior dev, the expectations are low. All I'd expect you to know is how to get code up and running that I don't have to tear down for the good of the company. Be able to read your language and solve simple problems. The biggest thing I look for in a junior dev is if I can give them some piece of of the software to write while I'm not looking and feel that you're mostly there when I come back to check. Apply for appropriate positions and don't fudge your experience. Enthusiasm and eagerness to learn go a long way. Don't be a know-it-all from your position.
Decide what kind of role you'd prefer, and start the process of brushing up on that. Use the job postings that represent the jobs you want as direction on what you need to learn. If the role you really want is too far, get a job doing what you know to pay for your education in the role you want.
As a front-end developer, you're going to want to learn a Javascript toolchain and one modern framework to start. Npm and Node.js are the backbone of what you do. If you want to switch, learn what juniors do in that paradigm. Do know that the Javascript world is fast-paced and fad-based, so if you miss a wave, wait two years and the next one will be coming around for you to hop on.
Personal projects are a good idea, just make them meaningful by using the proper setup (not just some bullshit hack job) or address an interesting problem. You're going to want to get it up on a personal repository that you can put a link to right on your resume and job site (Indeed, Dice, Glassdoor, Linkedin) posting. Be able to speak to every decision you made, even if it was a bad one. Your personal project doesn't have to be spotless or even completely done, it just has to be yours, it should be able to execute, and you should show some decent decision making. A mod for a game, a contribution to open source, a personal thing that has some use-case or whatever.
Get experience with related technologies. Start to learn one step before and beyond the one you're a specialist in. For example, you're a junior front-end dev. Learn a little about backend work, and learn about deployments. Learn about the experience of your fellow team members as they try to integrate your work with Git, build with Jenkins or AWS Code Build, and containerize with Docker. Think about the pain points you face in architecture, code, building, and deploying; think about how you'd solve them or if you can't, keep an eye on solutions as you go. Know the differences between elements of your chosen sphere.
Higher level concepts like SOLID principles,Design Patterns, and Refactoring Patterns are more goals than expectations, but you should take a look at them now and at least be able to speak to at least one of them somewhat. With limited time, prefer Design Patterns. You don't want to walk into an interview where someone asks you about how you use design patterns and you've never heard of them. Even if they'll accept that, you still won't feel good about it.
Look up some materials on coding challenges, as some companies give coding quizzes. I just had an interview with a guy that touted 10+ years of experience but couldn't read from a file given an hour.
If you feel like you're going to be let go due to performance, get ahead of that and ask your supervisor how you're doing or what you need to do to grow. If you feel like you're going to be let go due to a restructuring you can't affect, you have two options: get to know other teams so you can maybe hop on their project later, or just save your money and get to work on some of the stuff above each weekend until the axe falls. You're a junior dev. You're not expected to be perfect, but you should come in a teachable state - some foundation with programming, a willingness to learn, a willingness to figure things out, and the ability to take direction.
Design Patterns (aka Gang of Four)
https://www.amazon.co.uk/Design-patterns-elements-reusable-object-oriented/dp/0201633612
While data structures and algorithms are important, don't forget design patterns!
Design Patterns: Elements of Reusable Object-Oriented Software https://www.amazon.com/dp/0201633612/ref=cm_sw_r_other_awd_FW0ywbGSR9PB5
There are several good books on designing good software:
Code Complete
Design Patterns
Refactoring
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.
> You can get away with using Python now, in my mind, and this is a feat unimaginable 5 years ago. But I never want to.
Not even with the interactive beauty and wonderfulness of IPython Notebooks? :)
> Bokeh looks nicer than raw matplotlib, but I'm not sure why it reminds you of ggplot
Because both are explicitly based on The Grammar of Graphics (the "gg" in "ggplot").
> Copying Matlab style plotting has always been a mistake in my mind.
Again, it's explicitly a goal of Bokeh to leverage the experience of existing R/ggplot users in much the same way that matplotlib tried to appeal to Matlab users.
Agreed that I don't like matplotlib's imperative style, but much of its functionality is now exposed via multiple APIs — it's now possible to use it much "less imperatively".
>How did you learn this?
With a Computer Engineering degree and a friend in Comp Sci I could pester.
Here's some of my reading list:
I'm sure there's plenty of specific details I'm forgetting, as well. I'm decent at being a Katamari of information gathering, but I'll be damned if I can remember where lots of it came from.
> Computer science is about building things like engineering but without the luxury of a toolbox and components taken from the physical world. No one has worked out reliable and effective procedures for building large pieces of software as the engineers have done for physical project.
At first, I started to take issue with this statement because of software patterns. But I he means more than this. The author's points were thus:
IMHO, the author's points are a human problem, not an engineering problem. In point 1, a project manager didn't set expectations for a client. In point 2, developers did not use tools that exist. Buffer-overrun protection DOES exist (his example), and other technologies help modularize software properly. Hell, cohesion and coupling are among the core software design principles. In point 3, again, a project manager did not properly set expectations for the client. PM technologies like agile methods have been developed to fight this. Further, because software is much newer to the human knowledge collective, it's less well understood. When it has been around for as long as architecture and machines, clients will have better expectations of the process.
In all, it sounds like his experience with software has not been true engineering rather than modern software development techniques.
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.
Not specifically game-related, but the great classic Design Patterns: Elements of Reusable Object-Oriented Software is really well written, and it's patterns are as applicable to game design as they are for anything else.
You do say you're an experienced programmer though, so you may already know many of the basic general design patterns in there (or you may have read the book even).
It really depends on your use case. A good starting point (I'm assuming architecture in software) would be to read Design Patterns by Group of Four. It uses C++ for it's examples and is quite a dense read, but is worth the read.
I'll start off with some titles that might not be so apparent:
Unexpected Fundamentals
These 2 books provide much needed information about making reusable patterns and objects. These are life saving things! They are not language dependent. You need to know how to do these patterns, and it shouldn't be too hard to figure out how to implement them in your chosen language.
 
Good General book
 
This book is great if you're going to make a browser based game
 
General Knowledge books
 
Provide a working moveable 3D model with C++ and DirectX, Very cool.
 
More general game base building
 
Working product results books, little if any modification needed
Releasing in a couple months (hopefully) 2 Very good books using C++ to develop by.
 
Not presented in the best manner but still noteworthy:
 
I used to love XNA...but now it's not feasible for commercial development. If you're a beginner to game design...starting out with XNA might actually be useful. It's easy to pickup and put out a working product. XNA is C#
 
 
Working product books, modification needed to make run on current systems
Provides a working FPS game in C++ on DirectX 9. Good for some starting out knowledge for an FPS
 
Good for 3D Terrain rendering in DX9...however much of this is outdated...some concepts still apply, and it's not the worst idea to see a working example.
 
TLDR: Click links starting at top, buy, read, profit
Vezi si fast.ai, au 4 cursuri foarte bune. Apoi si asta e bun. Hugo Larochelle avea un curs de retele neuronale, un pic mai vechi.
La carti as adauga si The Hundred Page Machine Learning Book si asta , probabil cea mai buna carte practica, da asteapta editia a 2a, cu tensorflow 2.0, are tf.keras.layers, sequential model, practic tf 2 include keras si scapi de kkturile alea de sessions. Asa, si ar mai fi si asta, asta si asta. Nu pierde timp cu cartea lui Bengio de deep learning, e o mizerie superficiala. Spor la invatat si sa vedem cat mai multi romani cu articole pe ML si DL!
Learning JavaScript is pretty good advice since it's useful in its own right, but honestly any company that expects a Jr. Java developer to have any kinda deep insight is being just unreasonable, and probably isn't a very good place to work. Everybody starts somewhere, Java developers included.
That said, for anyone wanting to learn design patterns, I suggest the classic GoF book: Design Patterns: Elements of Reusable Object-Oriented Software.
Just.
Please.
Promise me if you read it you won't use Visitor for anything ever.
I will suggest start with Head first design pattern. That will gradually build your intuition about good software design. And it’s more fun to read compared to GoF imo. On top of that, there are Youtube videos by a guy named Christopher Okhravi on design patterns. Since I understand much better with videos (along with text book) because of my attention deficiency, they really helped me.
Apart from that, follow tech blogs of Netflix, Google, AWS, Uber etc. They are treasure troves.
Also, as /u/ibsulon mentined, Clean Code for writing good quality code, Programming Pearls and Pragmatic Programmer etc. Effective java and Doug Lea's book on concurrent programming - really helpful.
the book is just called "Design Patterns?"
This?
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.
Seconding The Pragmatic Programmer and Cracking the Coding Interview. I'd also recommend:
If you let us know which languages you primarily write, I can probably recommend some good language-specific titles, too.
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.
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:
Design Patterns by Erich Gamma , Richard Helm , Ralph Johnson , John Vlissides
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_3?ie=UTF8&qid=1549541116&sr=8-3&keywords=design+patterns
Concurrency in Practice by Brian Goetz
https://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601/ref=sr_1_1?ie=UTF8&qid=1549541190&sr=8-1&keywords=concurrency+in+practice
Clean Code by Robert C Martin
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_sim_14_4?_encoding=UTF8&pd_rd_i=0132350882&pd_rd_r=cf3a76e3-2ad0-11e9-91c7-79eddbe046cc&pd_rd_w=RVwGU&pd_rd_wg=ZJ2Iq&pf_rd_p=90485860-83e9-4fd9-b838-b28a9b7fda30&pf_rd_r=4P48EDFQ0VNRGZYAE96S&psc=1&refRID=4P48EDFQ0VNRGZYAE96S
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
​
I'm big on modeling, objects, etc. so reply back if any questions.
Design Patterns: Elements of Reusable Object-Oriented Software doesn't use JS for it's examples, but is highly regarded in learning design patterns.
Also, Mastering JavaScript Design Patterns is pretty good, and if I recall correctly, is modeled after the first book I mentioned. Heads up, there is a more up to date 2nd edition of this book available (linked version is 1st edition)
A good place to start might be learning some of the common design patterns, these are common solutions that have been found to work over and over. The standard book for learning them is this one: http://www.amazon.com/Design-patterns-elements-reusable-object-oriented/dp/0201633612
It's not a PHP book but the patterns it covers can be used in any language, there's also loads of stuff on Wikipedia around them: http://en.wikipedia.org/wiki/Category:Software_design_patterns
Learning how to approach a programming problem is at the heart of being a good programmer and it's something you'll always be able to improve on (I'm still learning after 15 years of programming) so I would recommend a combination of trying to read as many programming books as you can, asking for help on StackOverflow when you need it, looking through well written open source code to see how those guys approach problems and above all else, practice, practice, practice.
This is a really big question, and not really specific to javascript. Architecting large applications, in my opinion, is kind of an art form. You can learn strategies by reading, but you're not going to get good at it without years of experience. Ideally you learn this stuff while working alongside strong senior developers who know what they're doing.
Read Design Patterns, if you haven't. I'd also recommend Javascript Alongé, but I'm a functional programming crazy.
Build something in a way that feels right, then evaluate what worked and what didn't. Which parts sucked to modify when requirements or assumptions changed? Which parts were hard to understand a month later?
In general, I have a few guidelines:
The "gang of four" book titled Design Patterns is an excellent reference for object-oriented architectures.
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Note - this really is more like a reference book than a tutorial or gentle introduction. It's not something you read cover-to-cover.
Per testare le acque velocemente puoi usare https://rubymonk.com/ (introduce Ruby in modo basico). Anche Coursera, Khan, Udacity e simili hanno corsi introduttivi sulla programmazione.
Mentre se vuoi imparare a programmare, il percorso deve toccare almeno tutte queste tappe, in ordine:
Organization-Design-Fourth-Edition/dp/0123744938)
Da qui puoi partire e specializzarti in quello che ti interessa
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'm freshening up on Python for work, and these are my materials:
Mastering Python Design Patterns https://www.amazon.com/dp/1783989327/ref=cm_sw_r_cp_awd_kiCKwbSP5AQ1M
Learning Python Design Patterns https://www.amazon.com/dp/1783283378/ref=cm_sw_r_cp_awd_BiCKwbGT2FA1Z
Fluent Python https://www.amazon.com/dp/1491946008/ref=cm_sw_r_cp_awd_WiCKwbQ2MK9N
Design Patterns: Elements of Reusable Object-Oriented Software https://www.amazon.com/dp/0201633612/ref=cm_sw_r_cp_awd_fjCKwb5JQA3KG
I recommend them to OP.
I would add design patterns to that list...they are extremely helpful and it essentially what modern frameworks try to put in place.
It's why MVC/etc exists, and if you are fluent in many design patterns then you can mix/match/modify the appropriate one to your current problem set. Also, things like that transfer to non-backend development if you ever decide to go that route.
See books such as Design Patterns: Elements of Reusable Object-Oriented Software - written by the 'gang of four'...and other related and more modern derivatives of this.
Everybody's learning style is different. Here are some books I believe to be essential for any novice or pro.
Programming For Dummies. It has a stupid title, but it is well reviewed for good reasons. I read through this beast in three weeks. There is no coding involved, as it is mostly theory, but it covers most of the bases of computer science and programming logic. Looking back, much of it confused me at first read, but the big ideas are all presented here. Reading this during the summer before first semester was a huge boost for me. All of the major computer languages are discussed in the book.
Cracking the Coding Interview. A book meant for veterans trying to get into highly demanding top tech companies, the book is a great introduction to programming paradigms. There are numerous examples of problems in each chapter with answers at the back of the book. The whole thing is in Java, with a short chapter on C++.
Design Patterns. As you learn more about object oriented programming, the concept of design is introduced. This book is the holy grail of software architecture and recommended by many. I would hold off acquiring it until you are certain that CS is where you want to be, it is quite technical. This book follows C++, although a Java version of the patterns exists on Github.com
A non-technical book just for fun:
The Innovators is essentially the story of computer science and how it got to present day. It follows the characters, human beings, that were involved each step of the way right up until modern day. Your professors will be impressed that you know who Alan Turing, Grace Hopper, and Charles Babbage were. If only I had been at THE MOTHER OF ALL DEMOS! The actual stories of Microsoft, Apple, The internet, the PC, video games, the space program, etc. On Quiz Up, a trivia app, every other question in the CS category involves names from this book. Read it just to be a real geek that knows where this stuff came from, and the drama/tension that led to innovation. The book is actually really funny at times.
I have included some links for more information about myself in the original post.
To have a better idea of the type of person I am these are the books within my arms reach right now:
Design Patterns: Elements of Reusable Object-Oriented Software
[Refactoring: Improving the Design of Existing Code](
http://www.amazon.ca/gp/product/0201485672)
The Mythical Man-Month
Along with some other ~50 similar books I've read.
There are books out there, many of which are unfortunately not language agnostic, that deal with this. What you want to know is the basics of object oriented design and, most importantly, design patterns, which are general answers for recurring object-oriented design challenges. You may have to dabble into languages other than the one(s) you currently use in order to follow along.
The last one is the book on design patterns.
The subject isn't particularly popular as far as I can tell, but Li and Vitanyi is the main (only?) comprehensive reference. I thought it was quite well written, and it starts from 0. To be able to get through the problems you'll probably need to have an undergrad background in CS or math.
I'm not sure what your background is, but usually one starts off in TCS by reading Sipser's text on the theory of computation. I'm not particularly advanced, but I've taken a few classes in TCS so I could elaborate more if you like?
The most famous textbook on 3D reconstruction is Multiple-View Geometry in Computer Vision, but I'm afraid it's much too complex for you now.
You need to know how matrix and vector operations work, understand projective geometry in 3D (like rays, intersections, planes etc.); learn epipolar geometry and understand the difference between the essential matrix and fundamental matrix; also take a look at some numerical methods and estimation methods (eg homogeneous least squares).
In the meantime, I suggest you take a look at this book: Programming Computer Vision with Python (you can download it for free), there's a chapter explaining the basics of 3D reconstuction with sample code, this can be good motivation for you.
And be patient, this is a pretty complex field, so better learn the basics first!
Depending on what you want to learn:
PYTHON SPECIFIC
You mentioned building websites, so check out the flask mega tutorial. It might be a bit early to take on a project like this after only a month, but you've got time and learning-by-doing is good. This'll teach you to build a twitter clone using python, so you'll see databases, project structure, user logons etc. Plus he's got a book version, which contains much of the same info, but is good for when you can't be at a computer.
The python cookbook is fantastic for getting things done; gives short solutions to common problems / tasks. (How do I read lines from a csv file? How do I parse a file that's too big to fit in memory? How do I create a simple TCP server?). Solutions are concise and readable so you don't have to wade through loads of irrelevant stuff.
A little while down the road if you feel like going deep, fluent python will give you a deeper understanding of python than many people you'll encounter at Uni when you're out.
WEB DEV
If you want to go more into web dev, you'll also need to know some HTML, CSS and Javascript. Duckett's books don't go too in depth, but they're beautiful, a nice introduction, and a handy reference. Once you've got some JS, Secrets of the javascript ninja will give you a real appreciation of the deeper aspects of JS.
MACHINE LEARNING
In one of your comments you mentioned machine learning.
These aren't language specific programming books, and this isn't my specialty, but:
Fundamentals of Machine Learning for Predictive data analytics is a great introduction to the entire process, based upon CRISP-DM. Not much of a maths background required. This was the textbook used for my uni's first data analytics module. Highly recommended.
If you like you some maths, Flach will give you a stronger theoretical understanding, but personally I'd leave that until later.
Good luck and keep busy; you've got plenty to learn!
Most of the design patterns introduce by GOF (gang of four) is still applicable today. Buy and read this book
Study design patterns and read books by the masters.. Find the books that are recognized by the community as "the best". For example "Effective Java" is one of the best books on writing Java beyond the basics.
The Pragmatic Programmer: From Journeyman to Master
http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?s=books&ie=UTF8&qid=1374154408&sr=1-1&keywords=pragmatic+programmer
Design Patterns
http://www.amazon.com/Design-Patterns-Elements-Object-Oriented-ebook/dp/B000SEIBB8
http://www.amazon.com/gp/product/020161586X/ref=oh_details_o05_s00_i00?ie=UTF8&psc=1
You can always read books. Textbooks are much better to read when you're free to browse and pick out whichever ones you like. You can get a surprising amount of reading done just by reading on the bus, on the can, and whenever you've got nothing better to do.
A popular stack overflow answer has a pretty good list. You can preview the introduction of most books on amazon.
People like to champion the internet as "oh, you can learn anything on the internet!" Which is true. But you can learn it much faster and better from a book (generally speaking).
Books provide a long format which has a chance to build upon itself. Also, everything is collected in one place for easy access. More developers ought to sit down and read good books.
I'll be honest with you, I don't think Head First Java would be a good choice, however DO READ Clean Code. I also suggest Design Patterns: Elements of Reusable Object-Oriented Software and Working Effectively with Legacy Code. The first is a classic MUST READ for anyone in software development. It present numerous challenges that most of us will face when developing solutions, and gives you the design patterns you will need to solve them. The second is great for learning how to fix your predecessors shitty code, you'll need this one. If you haven't already, look up Bob Buzzard and Andy Fawcett. These two guys are my favorite SFDC Dev Bloggers. I also suggest watching any Salesforce Webinar that has anything to do with code, especially security stuff.
Practice makes perfect, except for us there is no perfect, just better. Know your best practices and live by them. With everything you do ask how can I make it better? Faster? More efficient? Do I even need code, or will Workflow/Process Builder/Flow do? How can I write code, so that an Admin can customize it without any code?
> Based on code reviews--my code is pretty good, with good logic and pretty well laid out.
This is actually VERY important, having good logic is obviously crucial, but being well laid out is a kind of hidden requirement with code. You or somebody else will eventually need to maintain your code, if it's laid out well it should hopefully be easy to read and maintain.
When you write code do your best to incorporate declarative features so that further customization can be done without code (I know I said this earlier, but I think it's important). Need to write some code that uses an arbitrary set of fields, consider using Field Sets. An Admin can add/remove them without code. Maybe use a Custom Setting, or Custom Metadata to map fields to values.
Learn how to use Describe calls for everything. Need to write some code that catches dupes and merges them? Don't hard code the values, then nobody will be able to remove or add fields without updating code. Instead use Describe calls, now you get every field on the object forever. Need to remove a field from an object no problem. Need to add a field to an object no problem. Does your losing record have child records that need to be reparented? Don't hard code, use Describe calls to get all sObjects with a Child Relationship. Use Describe to find out if it can be directly reparented or if it needs to be clones (CampaignMembers can't reparent a LeadId to a new Lead. You MUST clone and add the new Lead Id).
How much do you know about HTML? CSS? JavaScript? JQuery? Visualforce? Learn 'em. Lightning is coming, and these are going to be more important than ever (except maybe Jquery).
Practice, practice, practice. One coding assignment per month isn't that bad, but if you get some work done early and you have an hour or two to spare, work on a side project. Can you think of something in your company that could be automated, spin up a Dev Org and give it a shot. Maybe your Sales people could use a new VF page for entering information just a little quicker.
Always seek to improve your code. Always seek new ideas and better ways of doing things.
Trailhead is good, do all the coding ones you can find, it's more practice!
I have the first edition and yes, it worth a read, keep in mind that it explain how game engines works and not how to make a game engine.
After reading it you will not be a master with UE4 but you will undertstand why UE4 do things in a certain way.
Another book you have to read (and is mentioned in your link) is the Game Programming Patterns book, i have the physical copy and it is awesome, read it after the GoF Design Patterns book, is a masterpiece combo.
EDIT:
Also two sites i want to suggest:
Learning Modern 3D Graphics Programming, is a great tutorial about OpenGL basics.
The Book of Shaders, great to learn how shaders works.
FFS... just stop. This is NOT a Mediator Pattern
Three articles that are either partially or completely wrong in three days? Just. Stop. Go get this book... read it... then try again.
You can't just "invent" patterns and name them after existing patterns because you named one of your objects "mediator".
A Mediator Pattern in JS explained by someone who knows what he's talking about
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.
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.
As far as your courses go, the best book I can recommend is Algorithms in a Nutshell. It is a small book which quickly introduces you to most of the core algorithms you will use throughout University. It also covers measuring efficiency through "big O notation" - a very important concept in CS.
If your University's SE program is anything like the one I am familiar with, you will also be focusing on software engineering principles. The most important SE books I ever read are:
These three books have strongly influenced me as a developer
The "Gang of Four" design patterns book http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&s=books&qid=1251223171&sr=8-1 is the one that started it all. There are code samples in C++.
I've also heard good things about the "Head First Design Patterns" book.
I didn't look through your code.
Just some general advice: Don't force design patterns into your app. Design patterns are solutions to common problems. You should just be familiar with them to recognize when you're trying to solve a common problem.
You should read this:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&qid=1427141980&sr=8-1&keywords=design+patterns
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.
Design Patterns (sometimes called the "gang of four" book) is the best book I know of about design patterns- and I haven't heard of it being used in college courses (I could be wrong). This will give you a sense of the patterns that are out there, but knowing which pattern to use when is still mostly experience and even team-based preference/convention.
CS programs give you a broad overview of computer science theory, which is helpful but is not in any way sufficient to prepare you for programming practices. What you're going through is totally normal.
Debugging someone else's code is a skill that is also not taught in schools. I actually did a talk on debugging skills a few years ago; the slides don't make much sense but we made a PDF of our main points. I'll see if I can find video when I'm not on my phone.
I'm happy to talk more about this stuff with you or anyone else reading this; pm me or email carol dot nichols gmail.
FWIW, although Bokeh is itself not an implementation of the Grammar of Graphics, many of the original Bokeh authors, including and especially myself, were avid fans of Wilkinson's approach. I would say those ideas (and their structure and consistency) greatly informs the structure of Bokeh.
I bought this as a student, when I didn't have the maths to understand half of it, because the idea was so attractive. So speak for yourself.
Musk is literally attempting to save humanity.
> Algorithmic information theory doesn't study induction
I'm not so sure; one-eighth of my textbook treats inductive reasoning.
> SI does help with assigning prior probabilities
Actually, Kolmogorov Complexity is the proposed mechanism for valuating priors. SI is a Bayesian reasoning vehicle that subsumed KC when it calculates its universal prior.
> The question decision theorists and epistemologists want to ask is "what explains the justificatory relation" or less question beggingly "is there a justificatory relation".
The question SI seems most vested in answering is: "how should one build, and what are the properties, of an ideal inductive engine". An exemplative result:
> This result implies that ξ(xt|x<t) will rapidly converge to µ(xt|x<t) with probability one as t → ∞. In a stochastic environment “with probability one” is usually the strongest guarantee that can be made so this is a strong result. Roughly it states that the expected number of errors will be finite and Bayes mix will eventually be the same as the true predictive distribution.
Such a result does not directly answer to the justificatory relation, but I could see evidences like it being used to construct such an argument.
Na verdade eu sou físico. Acho que é mais comum entre os físicos adotar uma perspectiva bayesiana do que entre os matemáticos ou mesmo os estatísticos. Talvez por causa da influência do Edwin T. Jayes, que era físico. Talvez por causa da conexão com teoria de informação e a tentadora conexão com termodinâmica e mecânica estatística.
O meu interesse pela perspectiva Bayesiana começou por conta do grupo de pesquisa onde fiz o doutorado. Meus orientador e meu co-orientador são fortemente bayesianos, e o irmão do meu orientador de doutorado é um pesquisador bastante conhecido das bases epistemológicas da teoria bayesiana (o físico uruguaio Ariel Caticha).
Tem vários livros bons sobre probabilidade bayesiana, depende muito do seu interesse.
O primeiro livro que eu li sobre o assunto foi justamente o do Jaynes - Probability Theory, the Logic of Science. Esse é um livro um pouco polêmico porque ele adota uma visão epistemológica bastante forte e argumenta de forma bastante agressiva a favor dela.
Uma visão um pouco alternativa, bastante conectada com teoria de informação e também fortemente epistemológica você pode encontrar no livro Lectures on Probability, Entropy and Statistical Physics do Ariel Caticha - (de graça aqui: https://arxiv.org/abs/0808.0012). Eu fui aluno de doutorado do irmão do Ariel, o Nestor Caticha. Ambos têm uma visão bastante fascinante de teoria de probabilidades e teoria da informação e das implicações delas para a física e a ciência em geral.
Esses livros são mais visões epistemológicas e teóricas, e bem menos úteis para aplicação. Se você se interessa por aplicação tem o famoso BDA3 - Bayesian Data Analysis, 3ª edição e também o Doing Bayesian Data Analysis do John Kruschke que tem exemplos em R.
Tem um livrinho bem introdutório também chamado Bayesian Methods for Hackers do Cam-Davidson Pylon (de graça aqui: https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers) que usa exemplos em python (pymc). É bem basicão para aprender aplicações de probabilidades bayesianas.
O livro All of Statistics do Larry Wasserman tem uma parte introdutória também de inferência bayesiana.
Se você em interesse por inteligência artificial um outro livro muito bacana é o do físico britânico (recentemente falecido) David Mackay - Information Theory, Inference, and Learning Algorithms (de graça aqui: http://www.inference.phy.cam.ac.uk/mackay/itila/). Esse livro foi meu primeiro contato com Aprendizado de Máquina e é bem bacana.
Outros livros bacanas de Aprendizado de Máquina que usam uma perspectiva bayesiana são Bayesian Reasoning and Machine Learning (David Barber) e o livro-texto que tem sido o mais usado para essa área que é o Machine Learning: a Probabilistic Perspective (Kevin Murphy).
First understand that my view is Bayesian to the core. I need no convincing that the majority of what we work with in the future will be probabilistic (and that is not statistical, the distinction matters).
You seem to use genetic algorithms as a catch all, or alternately believe that when systems become complex genetic approaches will be the only ones feasible. You're excluding anything between a SAT solver and a genetic explorer. In that gap lies 2 decades of profound advances that we now commonly call Machine Learning.
Genetic methods have played little part in these advances. In fact I just grabbed the best ML textbook I have close at hand (1) and the word 'genetic' does not appear in its index, despite it being a cookbook of 100's of state of the art ML techniques. Moreover we can look at the folks building the most complex computing systems on earth, like CERN or the US National Labs. What approaches do they use? Lots of Monte Carlo for forward simulation and classifiers derived from probabilistic graphical models (decision trees in particular) for comprehension. The Higgs boson was in fact found using decision trees. It's not like the folks on the Alice team don't know about genetic methods, they're just inferior for most purposes.
And in the far distant future, where again computational costs matter less and less, I can't see how a genetic approach would be more effective or convenient than unsupervised learning in a large fixed network. This is, after all, how the brains having this conversation work.
Murphy
BRML
ESL
"We don’t have to worry about strictly lining up the images since they won’t be displayed."
Pretty sure the cameras would have to be calibrated with respect to one another which is not a trivial affair.
This is a good resource for mocap / reconstruction:
http://www.amazon.com/Multiple-View-Geometry-Computer-Vision/dp/0521540518
First, I would say spend some time prototyping what you want with simple shapes. Experiment with what you can do and how you want to do it. Once you're satisfied with what you can do, breakdown the game into smaller tasks and list those out with target deadlines. Try to stick to one thing until it's done and move onto the next one. Smaller goals are easier to achieve and will give you the confidence and enthusiasm to keep going.
As for technical stuff, I would say read up on object oriented programming and programming design patterns. There are a few books out there that are specific to AS3 and explain the most common patterns well. Be careful though not to use design patterns for their own sake. Each pattern is meant to handle specific cases that arise commonly.
Finally, I would say don't try to re-invent the wheel. By this, I mean don't try to program your own engine, etc. There are several very good Flash game engines out there like Flixel, FlashPunk, etc. Leverage what you can from those so you can focus on your game. Also, have people play it early and often so you can get feedback and make changes. It's easier to make changes earlier in the process.
EDIT: As far as forums I have been a member of the following forums/blogs for years and they have a plethora of information:
gotoAndLearn
Kirupa
8-bit Rocket author of this book
The guy that wrote this paper also wrote a book: Fluid Simulation for Computer Graphics. Which was quite usefull. I also used additional books about PDEs and linear algebra.
I didn't use a code example. I think with stuff like this the hard part is to understand the math well and then the programming is not that difficult.
I haven't looked at the paper for a long time, but I don't think it describes the projection step in detail. But it is described in the book for a similar method.
You'll need to learn PostgreSQL first. (You probably already know that PostGIS is an extension of PostgreSQL). You will need to get an instance of PostgreSQL running, and then create the database, users/roles, schemas, tables and views you want for your project, like you would with any other RDBMS. It's relatively straightforward to use PostGIS after that. The extension adds a few new field data types (geometry and geography) which can store spatial data features. It also adds a lot of new functions that operate on spatial data. These are what you use to do spatial queries. You can see the full list in chapter 8 of the PostGIS documentation:
​
Chapter 8. PostGIS Special Functions Index
​
When your database is set up, you'll need to learn how to add data spatial data to a PostGIS database. There are ways to do that with some tools that ship with PostGIS installations. You can also do it through QGIS. I would suggest, after you're comfortable with PostgreSQL, going through the PostGIS documentation itself. There is also a book that you could check out: PostGIS in Action.
​
Finally, I would suggest taking very good notes. Write down the SQL commands that you use to every step along the way to build up the database and keep a record of the SQL that you use to query spatial data. I still refer back to my original notes every time I set up a new PostGIS database.
Software Architecture is a nebulous term that can mean different things to different people. I'm a software architect and there is no single definition for architecture.
Instead try to get a deep understanding of good programming concepts and patterns, while focusing on ways to scale both your application and resources. Introducing unit testing, continuous integration and industry best practices is a key part of good architecture.
Architecture is also more than just the technical side, it's understanding the business domain and making decisions based on that.
tl;dr figure out what architecture means to your business and find the best way to bring value from a high level.
The following books are good resources:
It will certainly take time. How long is hard to say. One thing is being exposed to code, and writing code yourself. Another thing is actually collaborating with people that are more experienced - that helped me a lot. An eye opener in my coding journey was the "Gang of Four" design patterns book (https://www.amazon.de/dp/B000SEIBB8/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1). The risk is that you will overdo design patterns at first, but that will hopefully settle :-)
>Is there any decent books on the GoF stuff?
The GoF book: Design Patterns: Elements of Reusable Object-Oriented Software by "The Gang of Four" (Gamma, Vlissides, Johnson, and Helm)
Although I admire the optimism for a lot of people here I feel they are not being very realistic. Like the mention of using sales experience to 'sell' yourself to employers: it's fine and dandy if you can bullshit your way into a job but if you can't actually deliver you'd be 'let go' within a month.
Learning a language is just one aspect. What's most important is doing actually a ton of programming. So make sure you have at least 3 moderately big projects with good code quality that follow best practices that you can show to employers.
Feel free to hop over onto /r/javahelp to have us review your code and suggest improvements. Being a developer isn't really about languages: it's about turning a customer's problem into a working solution. That's the hard part.
One last tip: for someone without any CS education but who is going into an area where OO skills are a must this book is a must read: http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented-ebook/dp/B000SEIBB8
Heck. Showing an employer that you read and understand it and apply it in your projects would give you a huge head up.
Skill - if you look at a book and can't even figure out what the topic is about then it's too advanced. EG: Entity Framework - if you don't know what an ORM is or why it would be a good idea to have a DAL then you might want to skip this and come back later.
Find a popular blog or podcast on your topic then browse through their articles and notes. They should be regularly recommending books or sites that are useful. Then take that book and google other sites for it. Find lots? Good book.
And yes, amazon reviews do matter. EG:
https://www.amazon.ca/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8
4.4 out of 5 stars, only one version ever published, and all the negative reviews are about the kindle version, and it's basically THE book for learning design patterns, even 20 years later.
Back in 2002, I took a graduate image processing course. The class text was Fundamentals-Digital Image Processing by Anil K. Jain.
http://www.amazon.com/Fundamentals-Digital-Image-Processing-Anil/dp/0133361659 Looks like my old university is still using it as the required text.
I also purchased Rafael C. Gonzalez and Richard E. Woods Digital Image Processing.
http://www.amazon.com/Digital-Image-Processing-Rafael-Gonzalez/dp/013168728X/
http://www.imageprocessingplace.com/
While taking the course, I primarily used the instructor's hand written notes and Jain's book. The Gonzalez book came in handy as a secondary reference.
On of my early managers had Gonzalez as his thesis advisor. I'm surprised how much these books have gone up. I paid 60.74 euros for Jain's book.
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.
There’s really no meaningful content, it’s all just very superficial IMO. You just keep saying what a patten is, list a few at the end and then you don’t explain them or even give examples. Lastly, no relevance to AngularJS in the article, which is the sub you’re posting in.
As far as AngularJS goes, I would recommend most people start with John Papa’s styleguide.
https://github.com/johnpapa/angular-styleguide/blob/master/a1/README.md
As far as JavaScript design patterns go, I would recommend this book.
https://addyosmani.com/resources/essentialjsdesignpatterns/book/
For learning about design patterns and a larger set of them in general, you can’t beat the Gang of Four
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Read the GOF design pattern book. For better or for worse, you can't write intermediate Java if you aren't familiar with the basic patterns of Java code
Sounds like what you've done is real/serious programming, just on a smaller scale.
I wouldn't worry too much about not knowing various frameworks. We use Spring to inject dependencies into our client code, we use Glassfish as our application server, and we use JPA backed by EclipseLink as the glue to our data layer. However, when it comes down to it it's mostly about writing plain old Java objects.
For the rest:
Rather than further enumerate my reading list, I'll point you to the Programming FAQ; an excellent resource for exactly the questions you're asking.
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&ie=UTF8&qid=1466670651&sr=1-1&keywords=head+first+design+patterns) is a much better introduction to design patterns for most people.
Well I'm 40 and didn't really "get" CS until I was in my early 30s, despite doing it for 10+ years prior. Once you turn the corner or whatever it is, things just make sense. For me what helped was going back to the concepts called "computational thinking", as described here https://www.cs.cmu.edu/~CompThink/
I understood the meanings of words like abstraction, recursion etc but didn't really know them as well as I needed to, and didn't know how to see these same basic ideas everywhere, take advantage etc. Also learning some design patterns such as explained in the gang of four book can be eye opening.
edit - book https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
> learn these patterns practically?
Maybe for now you might want to just read up on them and keep them in mind for the future. For further reading on design patterns pick up "Design Patterns: Elements of Reusable Object-Oriented Software". When you start building something plan it out before hand, preferably with pen(cil) and paper. Once you have some rough idea, see if you can recognize any place where design patterns would come into play. Sometimes they will be intuitively incorporated into your design process, or they will emerge naturally if you try and think holistically about a problem instead of moving your project along piecemeal.
>My goal eventually would be to land an entry C#/.NET position at some software company.
I would encourage you to learn ASP.NET MVC 5, a web framework like Angular or React, and Entity Framework. You may just want to learn the "Core" versions of ASP.NET and Entity Framework then go back .
I've taken this course on udemy on ASP.NET MVC 5, which I would recommend. The same author has put together another course on ASP.NET Core, AngularJS, and Entity Framework which I want to take soon. It looks like they are sequential given the requirements for each course, so you should take the MVC 5 course before you take the ASP.NET Core course. If you created a Github for a sample website (say a pizza shop where users can register, login, and order) and hosted it on Azure to show prospective employers, that could very well get your foot in the door.
Sadly, for a large part of the industry, Java and C# is the standard.
.Net still has a huge marketshare for developers, but Java is gaining quickly. Get proficient in either of these and some Agile development practices, as well as design patterns.
The Gang of four book is the standard design pattern book. I don't know off the top of my head what the best books to get on Java and C# are, but there are huge threads on StackOverflow that will point you in the right direction.
Good luck, my friend!
Two Java specific books you should read cover to cover (and keep around as an effective reference) are Effective Java and Java Concurrency in Practice, and you should also seriously consider reading Design Patterns. The examples in it aren't written in Java but they hold for all OO languages.
You could try the gang of four book on design patterns
Design Patterns: Elements of Reusable Object-Oriented Software - This is the object oriented design pattern bible.
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&qid=1495660409&sr=8-1&keywords=Design+Patterns%3A+Elements+of+Reusable+Object-Oriented+Software
This is one of those questions that basically yields no useful answers.
Not sure if I answered your question. You can checkout topics on design patterns. there's a good book on Amazon for that I think just called design patterns. Or checkout tutorialpoint.Com ? For software architecture.
Design Patterns Book
Software Architecture Quick Overview
edit: added resources and changed format
Just looking for learning, etc? If it's for interview prep, I'd give different recs.
I highly recommend:
These are both general references, I think there are a lot of syntactic python stuff that are unique and awesome, but algorithm stuff and OOP stuff is kinda language independent.
IMO you should go beyond learning node.
Learn javascript (node is just javascript with core libraries).
Actually don't learn javascript, learn how to code.
Even more, learn how to learn.
I'm not the only one with this opinion: http://blog.codinghorror.com/please-dont-learn-to-code/
Also a side point: learn how to test. Testing (may it be unit, behaviour, …) is really important. It helps you code better, have a stronger code (less bugs, or more easily identifiables), more maintainable, and so on.
If you know the basis of code, and how to learn, not only you'll know node, but you'll potentially know php, ruby, scala, whatever.
I strongly encourage you to read:
Those books are references to a lot of developers and will teach you techniques that you'll be able to apply not only to node, but to the most of languages you'll ever encounter.
Algorithms? Something like hackerrank.com because there you are supposed to create more complex algorithms from the "simple" ones you learn from books or perhaps in college or from Wikipedia/googling/free online resources.
Design patterns? That book specifically and anything from Robert C. Martin, but preferrably Clean Architecture.
If you are poor there are probably PDFs/epubs somewhere in the web but consider buying the books when they made you rich.
So I don't think you should get too hung up on "enterprise architecture" at the moment, partially because you're still very early in your career, but also because enterprise architecture means a lot of things to a lot of different people. At this stage in your career, I really think you should focus mainly on SOLID code, core Object Oriented design concepts, and then understanding patterns. Good architectural strategies are built around all of those concepts, but they're also much much more than that.
For SOLID code, one of my favorite references is actually Dependency Injection in .Net by Mark Seemann. Although he does spend a good amount of time on DI, the recommendations that Mark makes for how to properly structure your code in order to take advantage of DI are very useful in understanding SOLID oriented design principles in general. The examples and code really work through the concepts well, so you get a great explanation followed by some well thought out code.
Clean Code by Uncle Bob is a great reference on how to structure well thought out code that touches on some architectural principles, but doesn't have that as the main focus of the book. Many of the topics in the book you'll find need to be addressed throughout a codebase.
As far as design patterns (which are different then architectural patterns), I don't think you can go wrong with the original Gang of 4 book , although I personally have a C# specific version, C# Design Pattern Essentials. I don't want to put too much emphasis on design patterns, because sometimes they get overused and applied too literally, but they are still very useful. I think the key to design patterns is not just knowing what they are, but determining where they might be applicable to your use case, and whether you should make any small adjustments or tweaks to them.
After you really have a rock solid base of working with code, then you can shift your focus on more architectural concerns. For that, it really depends on what problem your looking to solve, but Domain Driven Design (DDD) is a good way about understanding those problems and to structure the solutions in a well thought out, loosely coupled, and evolvable manner. That "central framework" that you referenced in your post is the business logic, and its the key focus of DDD
The Pragmatic Programmer and Design Patterns.
The Pragmatic Programmer is a really enjoyable read about practical decision making and coding practices. Design Patterns is more for reference, both great books. You can google the design patterns though, but I like to have a copy of the book anyway.
By biology I don't mean what they teach you in college or med-school, I mean understanding the basic processes (physiology-esque) that underlie living things, and understanding how those systems interact and build into more complex systems. Knowing the names of organs or parts of a cat is completely worthless, understanding the process of gene-activation, and how that enables living organisms to better adapt to their environments, especially, for instance, for stress factors activating responses due to new stimuli, can be very valuable, especially as a function of applied neurology.
Also, what we call biology and medicine today will be so pathetically obsolete in 10 years as to be comical, similar to how most mechanics can rebuild a carburetor, but not design and build a hybrid drivetrain, complete with controller software.
Economics and politics are controversial, but it is a question of seeing the underlying forces that is important, similar to not understanding how gravity works, but still knowing that dropping a lead ball will accelerate downwards at 9.78m/s^2. This is a field that can wait till later though, and probably should.
For systems analysis, I'm sorry but I can't recommend anything. I tended to learn it by experience more than anything.
I think I understand what you are looking for better now though, and think you might be headed in the right direction as it is.
For CS I highly recommend the dragon book, and design patterns, and if you need ASM The worst designed website ever.
For the other fields I tend to wiki subjects then google for papers, so I can't help you there. :(
Best of luck in your travels however! :)
edit: For physics, if your math is bad get both of his books. They break it down well. If your math is better try one of wittens books, but they are kinda tough, guy is a fucking genius.
also, Feynman QED is great, but his other book is awesome just as a happy intellectual read
also try to avoid either kaku and hawking for anything more complicated than primers.
edit no. 9: mit's ocw is win itself.
edit no. 10: Differential equations (prolly take a class depending on your math, they are core to almost all these fields)
I was underwhelmed by code complete, although I had really high expectations after jeff atwood gushed about it so hard.
Design patterns I don't hear brought up very often but I found it extremely useful. Even if you don't use or even like some of the patterns you are likely to encounter them in your programming career at some point and being able to recognise them is invaluable.
Although I agree with the others and good coding pillars are important. C# can be incredibly easy to learn and as such it's great for beginners to start with. Focus small and build up from there. I would write simple console apps understanding the core concepts before you move into actual gamedev coding. Without a strong fundamental grasp of how C# works you'll end up rewriting code in your game later on as you learn new things. You might spend a good chunk of time doing something a very tedious way only to discover that there is a much easier way later on. Also as others have said code agnostic coding pillars are very important. Some good books:
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://gameprogrammingpatterns.com/contents.html
Understanding how to structure your code is very important.
Cara, reinventar a roda não é ruim! Resolver problemas clássicos é uma ótima maneira de aprender e praticar é a melhor maneira de melhorar em algo. Eu sou o tipo de cara que gosta de aprender as coisas na prática então sou suspeito de falar mas vai lá e desenvolve. Essa minha aposta com meus amigos é justamente para nos forçar a isso, desenvolve qualquer coisa mesmo que seja algo completamente inútil, que é melhor do que ficar parado. Umas semanas atrás, nessa aposta um dos meus amigos desenvolveu um script que calculava se era ecologicamente correto urinar no chuveiro ou na privada, utilidade real do projeto é nula, mas fazendo isso ele já começou a aprender uma nova linguagem e investiu tempo em se tornar um programador melhor. Realmente meu conselho é faça, desenvolva! Uma dica é pegue pequenas coisas do seu dia-a-dia e resolva elas com programação, por exemplo, uma vez eu fiz um script que me perguntava quais ingredientes eu queria em um lanche, ai ele varria o site do iFood e me falava qual era a opção mais barata que eu tinha. Não tinha necessidade alguma de fazer isso, era muito mais rápido fazer uma busca manual, mas na época isso me ensinou a usar a BeautifulSoup e foi super divertido de fazer.
Only ever fully read a single programming book, and that was because the material was best learned through a book. It was about non language specific design patterns. It was a key that unlocked so much knowledge for me.
The book is Design Patterns: Elements of Reusable Object Oriented Software. It's old but it does not matter. Object Oriented design patterns don't change much because they are tried and true, and you will see them in every OO language. While JS is not technically OO (though ES6 introduces some strong OOP features), it still uses many of the same patterns!
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Pretty broad topic... are you interested in graphics for games or more in the direction of image processing, computer perception etc?
For the later, this is probably the standard
textbook: http://www.amazon.com/Digital-Image-Processing-Rafael-Gonzalez/dp/013168728X/ref=dp_ob_title_bk
It first has some basic topics like images are stored, color spaces etc. which may be what you are looking for. Then it goes deep into analyzing image content, extracting objects etc. There are also various PDFs of it floating around.
That's what I get for being snarky. ;-)
There's another excellent book called Design Patterns that predates the Uncle Bob one, if you'd like to learn some history on the pattern.
I can't talk about Schildt's competence on Java. I know about his C books, which are pretty much recommended to be avoided. Bruce Eckel's on the other hand, I've heard only good about his materials (although I didn't really like his design patterns book very much). I've never read the two books you've mentioned though.
Have you tried the official tutorials for learning Java? They're very good IMO. They're freely available too.
My first book on java was The Java Programming Language (it teaches Java 5 [current version of java is 8]). Except that you'd be learning Java 5, which is still fully applicable, this book is very good. One of the authors is the creator of java, another is Guy Steele. He's a programming languages expert whose books I believe are worth reading just because he wrote it. He's pretty above the average, and also one of the creators of Scheme. Look him up on wikipedia =D.
I've read Core Java too (it has pretty up to date editions). I found it good, which is a win on its own since most learning sources are terrible IMO, but I didn't find anything particularly interesting about it. It does cover a lot of ground, though. I surely recommend it.
A lot of writing good java code is about understanding the usual patterns of which people make use.
The author of Core Java has a book on this (http://www.amazon.com/Object-Oriented-Design-Patterns-Cay-Horstmann/dp/0471744875/). I've never read it, but I'd guess it's good. I don't know how advanced it is though.
You can, of course, always look up the Design Patterns book (http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/). I'd not recommend reading this before learning java. I think you should only do it after learning some java. Although I don't think it's a particularly challenging book, I think it'll make a lot more sense given you can see its code examples (mostly in C++, and some in smalltalk; but mostly in C++) and understand what they do. You don't need to really know C++ for that, honestly. The code doesn't make use of any (IMO) advanced features of C++. Knowing java and using common sense I think is enough to understand what is in there.
There are many books on better using java. If you google for good java books, you'll find plenty of reviews, recommendations, and so forth. You can search amazon too.
By the way, a lot of the programming techniques for writing good code in one language can be learned by studying materials in other languages. For example, I owe much of my programming basis knowledge to K&R2 (The ANSI C Programming Language - 2e), SICP (Structure and Interpretation of Computer Programs), The Little Schemer, and The Seasoned Schemer. These books teach in C and Scheme (two languages that I probably will never use professionally), but a lot of what they teach I've been able to apply while coding in C++, Java, JavaScript, PHP, SML, Python, and also other languages I've used in the past.
Good luck.
Design patterns are simply canned OOP designs for commonly encountered forms of different problems. Design Patterns is a seminal text. It's worth pointing out that design patterns are not a gospel for developing software, but you will inevitably run across some of them and should be able to recognize a given design pattern when you see it.
What about some classics like Uncle Bob talks?
A lot of good design focuses on decoupling and creating components which work together but separately also.
Id first look into language agnostic design principles such as SOLID
https://youtu.be/TMuno5RZNeE
https://youtu.be/zzAdEt3xZ1M (golang)
A good book will help.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
I still keep a copy of the Gang of Four book at arms reach even tho the popularity is dwindling as OOP is not topic of most convos today. However when dealing with DI and sharable components in Golang, i find myself still falling back to abstract factories patterns. Its a good breathe of knowledge to at least glimpse at the patterns here:
Design Patterns: Elements of Reusable Object-Oriented Software https://www.amazon.com/dp/0201633612/ref=cm_sw_r_cp_api_i_7BzvDbXJC5WS4
Once you get thru these topics, you can start picking up what I consider the "hot" architectures of today:
Microservices, event based systems, domain driven design, event sourcing, and architectures aiding themselves to functional programming.
I really enjoy reading Martin Fowler blog posts: https://martinfowler.com/tags/application%20architecture.html
He covers a lot of these topics.
PS: maybe a niche and a personal favorite of mine but ive learned ALOT by researching the different types of kernel architectures. Nothing really geeks me out like those topic, but not for everyone.
A fabulous free course exists on these topics:
https://www.udacity.com/course/advanced-operating-systems--ud189
I have no formal training in CompSci, but this book seems like a pretty standard 1st or 2nd year text. It's one of the best technical book purchases I ever made, imho: Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process by Craig Larman. I would recommend it to anyone who wants to learn programming. Goes great with the classic "GoF" book, Design Patterns. For any particular language's syntax and libraries, I just read the docs and check stackoverflow or IRC for any tricky idioms and for best practices.
gratz. After you are done with learning java, you might find this book useful: Design Patterns: Elements of Reusable Object-Oriented Software
Read a lot of books. Everything is usually available as a pdf on the internet and the ones that aren't are $10 to rent on Amazon. Here's the ones that I've read that relate to this project.
Java
Android
Programming in general
I've been doing a lot of research lately on the best books in programming in general to start a blog about each one and their importance to an inspiring developer. These are two of the books which will help you greatly getting started on designing your first game.
The first book is completely about design patterns, you will need to learn about these as creating software in general requires knowledge of how specific design patterns work and when you should use those patterns. The second book in the list is a complete guide to creating a small sample game, albeit not in libgdx, it should provide you with enough material to get you started.
I also recommend the Game Programming Patterns and Game Engine Architecture books which were stated in a previous comment. I have both these books as well as the Game Code Complete book and will be buying the Design Patterns book I mentioned as it is the most highly recommended book for any developer.
> Is this stuff obviousl once you program more? Is it the study of software engineering? Computer science? Where can I learn about it?
No you need to work at it, yes, yes and on the job. You can start of the journey of learning this stuff through study and continue through experience. However it is a journey without an end, the landscape is changing, mobiles are the latest new technology but in 10 years time we will all be programming on devices we haven't even heard about yet.
> I want to learn classical program structures that common throughout programs.
There are some common design structures, especially for OO design with the book by the Gang of Four being a foundational work in this area. However knowing the patterns is just the start, knowing when to apply them and why they work is much harder and again comes from experience.
https://htdp.org/2018-01-06/Book/
https://mitpress.mit.edu/sicp/
https://mitpress.mit.edu/books/introduction-algorithms
https://www.amazon.es/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
https://www.amazon.es/Object-Oriented-Design-Heuristics-paperback-ArthurRiel/dp/0321774965
https://www.amazon.es/Design-patterns-object-oriented-professional-computing/dp/0201633612
In one year you will be properly equipped to look for a professional position :)
I'm not sure what your background is, but if you haven't had any formal programming education, I believe we learned out of a book like this: https://www.amazon.com/dp/0201633612/?tag=stackoverfl08-20
One of the keys to good software is good design. Making a plan of action before you even start coding cuts back on the 'quick fix' solutions that make your code harder to work with later.
I don't think this is C# specific, but design is really something that is abstract from language specifics. If you're looking for something specific to the environment you're working in, I think material on best practice for the game engine you're using would be better. I have done application development with C# and C# scripts in Unity, and there are definitely differences in how I am able to make things interact, which impacts how I design my code.
I have two recommendations if you're wanting to expand your abilities in design:
As far as the book goes, I can't condone it, but there's probably PDFs out there. Sometimes it helps motivate to actually read through it if you've invested some money into it, though. I would recommend finding an old/used copy. An old version of the book should work just as well as an 'updated' version.
You may also find it useful to look into Agile/Scrum. It's all about documenting your development, and helps to organize what's been done and what needs to be done, as well as give you an idea of how long things take, which helps later with estimations. All these things are skills that will come in handy later, if you decide to pursue software as a career. Plus, it's all good habits that help facilitate good, clean code.
Personal opinion: for language-specific books, the hands-on ones are the only ones worth reading.
If you want "bedtime reading", I'd suggest books that are broader than learning a specific language. Books that discuss algorithms, or design patterns...stuff like that.
Speaking of design pattern books...https://www.amazon.com/dp/0201633612/ Not sure how much mileage you'll get out of that, but it's considered one of the best design patterns books that I've ever heard of.
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:
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 :)
The Pragmatic Programmer
Design Patterns
Game Programming Patterns
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!
“Gang of Four” It’s the original design patterns book.
Like lots of new things, they got over-used. And misused.
Design Patterns: Elements of Reusable Object-Oriented Software
https://www.amazon.com/dp/0201633612
Generally the Adapter Pattern is what you're describing, but it could also be used in combination with a Façade or other Structural Patterns from the Gang of Four book.
For someone so spread out, one of the best things you can do is get a book about design patters / principles, as those theories spread across multiple languages.
General : http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1345469375&amp;sr=1-1&amp;keywords=design+patterns
This was a decent one for PHP: http://www.amazon.com/Objects-Patterns-Practice-Experts-Source/dp/143022925X/ref=sr_1_1?ie=UTF8&amp;qid=1345469244&amp;sr=8-1&amp;keywords=php+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 :)
Coding Style:
Currently there is a lot of discussion about the PSR-1 and PSR-2 standards. The PSR-0 is definitly something which you should know about and follow it.
OOP structuring, Design Patterns:
Understand design-patterns (the standard book on this topic by the gang of four), and have a look into the topics of MVC and dependency injection. Zend Framework 2 and Symfony2 are the two major frameworks in this context.
Maybe also learn to know how database patterns like ORM and/or Active Record work. (Frameworks like Doctrine2, Zend_Db,...)
Test Driven Devlopment:
Check out PHPUnit and Behat for Behaviour Driven Testing
Version Control:
Our teams (2-8 programmers) work with both Subversion and Git. I recommend to check out both. Each has its disadvantages and advantages. There is a lot of discussion out there.
Related to this is the knowledge of Continous Integration and the connected tools. (Keywords: Jenkins, Bamboo, phpUnderControl, Hudson)
One thing that may help is to read http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&amp;qid=1344312820&amp;sr=8-1&amp;keywords=design+patterns
And like someone else said, try to make something that interests you such as a simple text based game or simulation or something, and you'll learn good design over time.
> Books that old are also unlikely to talk about Design Patterns
The original GoF book was published in 1994.
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.
You should first learn the patterns and then apply them to what you're doing:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Probably not as useful to go the other way.
Boot camps might help teach certain technologies, but they might not help with the fundamentals. Additionally before you give money away try to complete courses on Udemy or Coursera to see if you can commit to the effort.
Over simplified recipe for building skills to transition:
If any buzzwords here might not make sense, congrats you get your first exercise in digging for answers ;) (no rudeness intended)
That book is sort of an applied version of the "Design Patterns" book by the "Gang of Four" that is frequently mentioned by the author. The "Design Patterns" book is an excellent reference book to have on hand that I would recommend to any developer. I have both books and of all my programming books (and I have a lot of them) they are probably my two favorites out of the bunch.
Disclaimer: This may not be true for your job, but it has been for every job I have worked at.
That everything they are teaching you about algorithms will not be useful to you when you get into the field. Your education starts day one at your first job. Clients don't pay us to innovate in algorithms. They pay us to find and glue together other peoples libraries and to use this to present them the requested information.
Code you will actually be writing:
Things you will be doing that CS degree does not prepare you for
I would suggest reading books like Design Patterns, Mythical Man-Month and Code Complete
Your foes are kids in their twenties with a degree which takes years to achieve, this will be tough! But I think your age and your willingness to learn will help you lot.
&#x200B;
Other things to learn:
&#x200B;
If there's one framework to look at, it would be spring: spring.io provides dozens of frameworks, for webservices, backends, websites, and so on, but mainly their core technology for dependency injection.
&#x200B;
(edit: other important things)
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:
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Here it is on Amazon. You can probably get a copy cheaper somewhere else though. https://smile.amazon.co.uk/Design-patterns-elements-reusable-object-oriented/dp/0201633612/ref=mp_s_a_1_1
Design Patterns by the Gang of Four is probably the most cited book on programming design patterns I've ever seen.
This is a good place to start: http://www.amazon.com/gp/aw/d/0201633612?pc_redir=1409630539&amp;robot_redir=1
As for android specific, no idea.
>Oh well, can't work on the past
Everything you do today is tomorrow's past.
You need to do some light learning. I'm linking a few books that are fantastic in accomplishing these goals and I think your english is pretty great, so I don't anticipate so much trouble. I highly recommend doing everything in Java; not because I'm arguing that java is what will help you the most, but because almost every code example from these classics refer to Java.
For design patterns, Gang of Four is a good introduction, but it's a little harder to understand http://amzn.to/1giIrF6
I would recommend finding AND implementing these patterns.
Grab a copy of Code Complete by Steve McConnel and Clean code by Robert Martin. That will help you write nice code that you'd be proud to share with a company.
I know it's temping to take the short cut and look for good examples of how to do it in angular, but I beg you to delay that as long as you can.
Instead, start by reading about design patterns in general. Once you understand the major design patterns, most of them appear regularly or can be replicated in language and framework you learn in the future. If you go into angular with this knowledge, you'll spot bad structure much more easily and know how to fix it. Then it's just a matter of looking at the APIs to see how to achieve those design patterns. You may still end up looking for good examples, but you'll have a much better foundation to work from and you'll probably understand the examples more easily and have some theories to help you do the things that aren't spelled out.
There are many resources for design patterns, including wikipedia. The design pattern bible is this book: http://amzn.com/0201633612
If anyone is interested in delving a bit more into this kind of algorithm, and particularly the math behind it, I highly recommend this book.
It's a bit dense, but if you have the patience and want to understand the math, it covers pretty much everything relevant.
I've heard this one's a classic, but I haven't read it, so I can't comment personally:
https://smile.amazon.com/Grammar-Graphics-Statistics-Computing/dp/0387245448?sa-no-redirect=1
I actually found the first page of this book about the subject http://www.amazon.com/Introduction-Kolmogorov-Complexity-Applications-Computer/dp/0387339981/ref=sr_1_1?ie=UTF8&amp;qid=1291565261&amp;sr=8-1 clearer than the explanation in GEB. But it is a great book.
http://www.amazon.com/Learning-OpenCV-Computer-Vision-Library/dp/0596516134
If you only read one work on the topic, it should be The Art of Computer Programming by Don Knuth: https://www.amazon.com/dp/0321751043/
The textbook for MIT's 6.001 (introduction to computer science) is the much loved Structure and Interpretation of Computer Programs by Abelson, Sussman, and Sussman: https://www.amazon.com/dp/0262510871/ . Originally it was in Scheme but the 2nd edition is in Python.
Finally, because people asking about computer science are often asking about something a bit broader than pure computer science, I recommend Code: The Hidden Language of Computer Hardware and Software by Charles Petzold. It is a thorough tour of computing in practice at every level, top to bottom. https://www.amazon.com/dp/073560505X/
Similar situation here. I have been studying for 4 months now on most free time (avg: 15 hr/wk). 3 days ago I started codecombat.com and have made it half way though that game. It is all starting to come full circle and beginning to really grasp the concepts. It is previous study, and code combat that has brought me to my current level of understanding of python.
Books I have read:
Code: The hidden language of computer hardware and software:
https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/073560505X/
&#x200B;
Automate the Boring Stuff with Python: Practical Programming for Total Beginners:
https://www.amazon.com/Automate-Boring-Stuff-Python-Programming/dp/1593275994
&#x200B;
Android App::
SoloLearn:Python:
https://play.google.com/store/apps/details?id=com.sololearn.python&hl=en_US
&#x200B;
Youtube:
Python programming in one video:
https://www.youtube.com/watch?v=N4mEzFDjqtA
I have probably watch this 25 times in the last 4 months. Can about recite the whole thing now. haha
&#x200B;
Game:
CodeCombat
codecombat.com
&#x200B;
Online Class:
https://www.edx.org/learn/python
&#x200B;
I have used all of these to different degrees of completion. I think if I had it all over to do again I would go in this order.
&#x200B;
I am going to try check.io out after I finish Code Combat.
&#x200B;
I am not an expert by any means and still have so much to learn. I can feel myself improving, I have no intentions of becoming a full time software developer in the future. I want to learn how to program because I consider it a useful skill. After seeing the amount of time I have put into Rocket League over the past 4 years, I decided to do something more useful with my free time which is limited anyhow, because of work and family. And who knows what the future holds, maybe one day I will be able to make a dollar with my programming skill.
This book is a good introduction:
https://www.amazon.co.uk/Machine-Learning-Science-Algorithms-Sense/dp/1107422221
From what I know, there's two basic ways most music recommendation services use. The one technique is to use an efficient comparison method called minhashing. But the basic idea is that you represent every song as a collection of users who like the song. The similarity between one user and another is the Jaccard similarity (the proportion of people in song A shared by song B). Minhashing is then used as more of a search algorithm for finding which sets share Jaccard similarity.
This works okay for a lot of things, but the music service Pandora actually does not use that method. They have a unique approach where someone (I think mostly grad students in musicolgy) actually sat down and listened to every song and filled out a little chart that said things like "minor key tonality" and you write in the tempo and all that. Like, just an exhaustive list. Then to find similar music they're using a distance metric of some kind, although I don't know all the details. But basically if you imagine every attribute a song can have as a dimension, a song is a point in high dimensional space and you're trying to find music that's physically closer. Pandora does also learn a little bit about what attributes are important to you, too.
In general, this sort of topic is part of a field called machine learning. I personally enjoyed this ML book which was maybe a bit heavy on math and theory and not so much on practicality, but I do think quite a few other more down-to-earth books on the subject have been published if you want to look around and find a good one. I also hear great things about the coursera class on machine learning and data science.
I used Machine Learning: The Art and Science of Algorithms that Make Sense of Data and Evaluating Learning Algorithms: A Classification Perspective in my grad course. They're both super to-the-point and are written in non-overcomplex language
I'm still a beginner gamedev-wise, but I like to recommend Advanced Game Design with Flash. I'm working on my first game thanks to this book.
The Essential Guide to Flash Games could also be appropriate (as it probably is a bit easier than the other book).
90% of any sim is building the sources and frequently you have to use those sources to define the initial shape of the sim because sims are not designed to handle them - for example, all detonations are supersonic, that's what detonation means (subsonic detonations are called deflagrations). Supersonic flows are highly compressible, they result in shockwaves, which most fluid sim software does not handle AT ALL, so you're left modeling them with particle & volume sources, leaving the fluid sim to handle the subsonic aftermath.
Pyro isn't anything magic, it's really just wrappers around a standard fluid solver, so knowing how these things work internally would be enormously helpful, but that's pretty nasty from a math standpoint - Rob Bridson (one of the principle authors of Naiad/Bifrost) has a book out, but it's not for the faint of heart - https://www.amazon.com/Simulation-Computer-Graphics-Robert-Bridson/dp/1568813260 .
Fundamentally, a fluid solver is its velocity field, that's the fiddly part of it. The individual parts of a fluid solve ultimately come down to how they affect the velocity field, everything else is really just HOW they affect that field.
Disturbance is a "random" value at every voxel, turbulence is a curl noise evaluated somewhat smoothly over the fluid's domain, same for shredding, vorticity confinement and every other operation you can control (word of advice, turn off all the shape operators on the pyro solver node and add individual gas disturbance or gas turbulence nodes into the 'velocity update' input).
Pyro is fairly heavy, so is FLIP, but if you understand the underlying math, they're generally not too bad, but in my experience, most people just know which shelf buttons to push and get completely screwed when they don't work as expected.
> Can you give me any more info on what types of things you simulate
There are so many different things. One example that involves physical simulation is rendering. Rendering, turning a 3d description of a scene into a 2d image, is all about simulating the pysics of light transport. Given a set of lights and surfaces you simulate how light bounces around and what a virtual observer placed somewhere in the scene would see. Another example is explosions. Cool/realistic looking explosions for movies involve simulating burning materials, fluid/gas movement, sound propagation, fracture, plastic/non-plastic deformation, the list goes on and on.
Here are some books that might get you started in the right direction
As for programming languages, you're definitely going to need to learn C/C++. Graphics applications are very resource initensive, so it's important to use a fast language. You'll probably also want to learn a couple of scripting languages like python or perl. You'll also need to learn some graphics API's like OpenGL or DirectX if you're on Windows.
I hope this helped!
For image manipulation and recognition i wholeheartedly recommend OpenCV and this very practical book: http://www.amazon.com/OpenCV-Computer-Application-Programming-Cookbook/dp/1849513244
Now, the math in computer vision is very heavy... If you want to really understand the theory you will have to study a lot.
Nicely done!
How are you finding Pixinsight? I've heard good things about Warren Keller's book (https://www.amazon.com/Inside-PixInsight-Patrick-Practical-Astronomy/dp/3319256807) and just found this website (http://www.ip4ap.com/)
Looks like there's some astigmatism at the corners of the image though, probably from the focal reducer not creating a flat image.
The bible that many, including me, swear by: Getting Started: Long Exposure Astrophotography.
If you purchase PixInsight (which you should if you're really serious about getting the most from your data), then buy this book: Inside PixInsight.
That's the scope I started with :)
The easiest way to get involved (IMHO) is to get a DSLR and a T-mount. This will allow you to attach a canon DSLR to the back of your scope. Now you can easily take pictures of the moon, planets, and brighter objects in the sky.
Deep Sky Stacker is a free image pre-processing program that will help you stack all of your images together with their calibration frames to get ready to do the processing to get the detail out of the image.
As for image processing, Pixinsight is what I use, and it's a hefty pricetag, but it's a one-stop-shop. It does everything you need it to do. I've seen others with exceptional results from using photoshop, but I have no training or expertise in it at all. Here is a fantastic book that explains the intricacies of PI.
For long exposure stuff, you'll need a high quality equatorial mount, and for even longer exposure stuff, you might need a guide camera, but you'd be surprised what a well aligned unguided mount can get you, especially for brighter objects (like M42 here) and shorter exposures. Instead of the 3 minute exposures I took here, you can take 45-second exposures and just collect buckets of them and stack them all together.
I've found data structures more useful than algorithms. This book is highly rated and imo a must read for all programmers.
https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8
> I learned in android studio and got to a level where I could create an app. Little did I know, it was just a giant main activity with 100s f methods. My friend looked at the code and told me I needed to learn polymorphism. Now I've redone the code so it's all inclasses.
Yep. This is a really common stage in learning. It sounds like you maybe went overboard and created way more classes than you needed.
Next time I might suggest starting with your working program with just one big activity, then splitting things into separate classes one at a time.
> Well, I have to keep updating a bunch of list sizes to the main activity, but the problem is that the polymorphism has the list sizes passing through 4 classes to get to the main activity. So, I set up a bunch of interfaces that react when things are done within the classes all encapsuled in one overreaching class. I don't know.
I think you're blaming "polymorphism", but polymorphism is just a tool. You can use it to make good designs or bad designs. It's quite easy to use it to design something that's cumbersome and less effective than if you had no classes at all, and it sounds like that may have happened here. It doesn't mean there's something wrong with polymorphism.
I think you're conflating two separate things here: (1) what's a good design, and (2) how do you make your code work.
(2) is easy. If you post a small, complete program that doesn't work, we can help you understand why. We can't do that if you just post vague questions and snippets of code.
(1) is hard. This takes years to get the hang of, and a lifetime to master. At a good software company you'd learn this slowly by mentorship - you'd have a senior programmer reviewing every change you make and guiding you through the design one feature at a time. You'd get help organizing your code long before it got to hundreds of functions.
If you don't have that option, or even if you do, I'd recommend the book Design Patterns as a way to better understand how to use polymorphism effectively.
You're also welcome to post such questions here, but they have to be very specific. You have to tell us what your app does, in a lot of detail, and how you've organized it into methods. I can't give you advice on something vague like "passing list sizes to the main activity" because I don't understand the purpose of the lists, the purpose of the sizes, or the purpose of passing them to the main activity.
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented-ebook/dp/B000SEIBB8
Try this. I heard it's quite good. I am going to start this one myself in a couple of weeks.
I think if you haven't read the GOF Patterns book, and then gone through the Cocoa apis and spent some time "pattern spotting", then you're probably not really a professional grade developer.
When "Patterns" came out, there had never been a systematic approach to describing common software abstractions or how they solve various problems. We call it "software engineering" but it is usually practiced more like software carpentry.
OTOH, mechanical engineers have been able to draw on references like 507 Mechanical Movements since the mid 1800's.
Really? I've always associated big-4/gang of 4 with this book
In the past couple of weeks, I've been reading Design Patterns: Elements of Reusable Object-Oriented Software. If you understand MVC and design patterns in general, it is a good reference. The bulk of the book consists of the design patterns catalog, but there's also a chapter that lays out the reasons for using patterns in broad strokes, as well as a case study involving reasons for applying multiple design patterns in a project.
More than just describing the patterns themselves, some of the book focuses on the interrelationships among different design patterns. As a caveat, it references C++ and Smalltalk in its code samples, but the concepts of structuring objects and their dependencies transcend languages.
Probably. It might take some refractoring, but you would need a SaaS like Parse to handle the cross platform sync. I never tried Parse, but I don't want to since it costs money after a certain quota. I've heard some horror stories of independent developers messing up their Parse and blowing through their quota as they failed to put a kill-switch.
Same. I started this project around November to learn Android development. I have a year off before I start college, so I thought of learning some software development. My only experience at the time was high school computer science using C#, so even if you are learning you can contribute. :) Even if it's intimidating you can contribute by submitting issues and such. I contributed to a small database library which was over my head, but I browsed the source to find out how to do something, found an typo in the SQL, and submitted an issue explaining the problem and how to fix it: he forgot a letter.
Although I started learning programming in 2014, if you need any advice on learning Android development, you can PM me. I can provide a list of books you can find online which are helpful for learning Java:
All these books are sectioned such that you only need to read parts you want to, so they are very good references. These books really helped in knowing the syntax of a language and knowing how to use the language which I found was very important for a project of this scale. My first version of it was so hacked together that it was impossible to refractor to add new features. These books really helped for the second version even though I couldn't apply what the books advised effectively.
Well, I pretty much hate it, but if you really wanted to you could pre-plan your projects using UML. You can find some free UML editors online if you look. ArgoUML is okay, but definitely needs improvement (like an undo feature).
Also if you are interested in programming patterns, the canonical text is the GoF book. If you search I'm sure you will be able to find a PDF version of it. There is also a website dedicated to talking about the same book in terms of the application to games:
http://gameprogrammingpatterns.com/contents.html
I would recommend reading this book: https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook-dp-B000SEIBB8/dp/B000SEIBB8/
Extremely useful concepts to have and understand. I love the use-case the book uses (a portable, rich text editor) as a way to teach you what patterns to use (and not to use). I'm 8+ years in industry and I find coming back to it extremely helpful.
It's my want-to-be-productive-while-on-my-phone go-to book. IMHO definitely more worth it than reading a "coding" book and not having a machine to try it out (I find reading about coding without doing coding to be non-productive, at least for me).
You can't go wrong with this classic.
Clean Code can probably help somewhere.
Do you know any Software Design Patterns? They are more of what you are looking for I think. Design Patterns are a way to structure your code so that you don't repeat yourself, keeps code understandable since it follows guidelines from the pattern.
Head First Design Patterns is probably a good place to start with that, and once you understand the basics I would recommend you read the highly recommended Gang of Four (it's nicknamed because of the four authors).
How about the Gang of four
It is a good book too.
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
we use the whiteboard for that. until he can read this:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
and k&r on his own, I will be teaching him
Would this be the book?
Coding:
Object Oriented Programming (OOP):
EDIT: People who are downvoting this are doing you a disservice out of ignorance. You must read Code Complete 2.
"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.
Design Patterns is a classic textbook on the subject.
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Unfortunately, I don't know any good free resources.
I've been trying to read everything and anything that interests me. You probably need a reading list of some sort. One book I can recommend right now is Design Patterns: Elements of Reusable Object-Oriented Software.
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
>mostly because you need to be good at a lot of mathemtics, is this true?
This is primarily for algorithms. It's pretty easy to be good at math, the hardest part I find for people who program is that they often don't think "outside the box" in breaking their program down.
I and others recommend programming in C#. You should be able to get off the ground with the following resources:
http://learncs.org/
https://mva.microsoft.com/en-US/training-courses/software-development-fundamentals-8248?l=D9b9nHKy_3404984382
https://mva.microsoft.com/en-US/training-courses/c-fundamentals-for-absolute-beginners-8295?l=bifAqFYy_204984382
http://www.amazon.com/Exam-98-361-Software-Development-Fundamentals/dp/047088911X
This list is for programming in general:
http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1453520022&amp;sr=1-1&amp;keywords=pragmatic+programmer
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1453520045&amp;sr=1-1&amp;keywords=clean+code
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1453520067&amp;sr=1-1&amp;keywords=gang+of+four
http://www.comp.nus.edu.sg/~stevenha/myteaching/competitive_programming/cp1.pdf
http://visualgo.net/
http://www.sorting-algorithms.com/
http://code.tutsplus.com/tutorials/3-key-software-principles-you-must-understand--net-25161
Not sure what language you are working in, but if it's an OOP then this book is father of code design. You can surely find something similar that's specific to whatever language you are working in also:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Make sure you comment really well and use naming conventions that make sense. Read about encapsulation, loose coupling, and inheritance. I just make sure you continue thinking about it until it becomes second nature and you have solid habits.
It's not even for a team thing, it's even for yourself. Eventually you'll go back to an old program and realize you have no idea what's going on.
EDIT: accidentally a word
This is THE reference on OOP patterns. And I mean *THE* reference: Design Patterns
I highly recommend it.
Coming from a programming perspective, I would be happy with this book, Design Patterns by The Gang of Four (http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612).
It's more programming related but still very useful for game developers.
Gang of Four; an industry nickname for the four authors who wrote this book
100 Rogues didn't require anything fancy. I tried using some AI algorithms that sounded cool, but if / elses served the design way better, once they were organized. If you're looking to learn how to turn the basics into larger projects, I'd read up on design patterns.
The bible: http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&amp;qid=1376607225&amp;sr=8-1&amp;keywords=gang+of+four
90% of the heavy lifting in 100 Rogues is a combination of Command and Observer patterns from that book.
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
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.
These books will bring your design skills up a notch and give you some material to back up your arguments in design disputes.
Can you suggest a website? Is this an example of what you mean? Or could you recommend a book? Is this a good example?
you could always buy the bible: http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_5?ie=UTF8&amp;qid=1425602201&amp;sr=8-5&amp;keywords=gang+of+four
otherwise, http://en.wikipedia.org/wiki/Software_design_pattern
That's not what I meant, sorry if I came off that way. My point is, you can read all the books you want -- but if you don't supplement it with code you write, they're just concepts. Even if you're not writing code, you still should be looking at pseudocode or example code to see how it's implemented. Talking about something is easy -- programming it is hard. What people say when they say to design first, they mean to lay out your program, your APIs, and everything else ahead of time. This is part of professional software development. In order to get to that step though, you're going to have to program. You don't recognize good OO or game design by just reading a book.
Regardless, for a good OO-book, check out:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
For a good book on game engine design, check out:
http://www.amazon.com/Game-Engine-Architecture-Jason-Gregory/dp/1568814135
If you want just game design and setup, there are more than enough resources at /r/gamedev.
Also, make sure to supplement everything with code you yourself write, or else nothing will stick.
Reading up about design patterns will give you some more abstract ideas about how you might construct programs, particularly object oriented. This book's a bit of a bible in that regard.
Design Patterns is the de facto standard, although Design Patterns Explained is probably better as an introduction.
Crap! I just ordered this book from amazon. Had I known about this free book I would not have.
https://www.amazon.ca/gp/product/0201633612
In terms of books, i think this is all you need. Read the intro, and do as it says, don't memorize it, just understand the ideas behind the concepts and come back to them when you need them.
> how do you avoid forgetting rarer patterns, so you can still use them in new designs?
I wouldn't worry about that. You should not memorize the patterns, just know them and understand them. Understanding them comes with practice, use them enough and you start to see why this is good. It's like formulas in math, at first you memorize them, eventually you understand them, eventually you can derive them.
Same idea with patterns, once you have enough experience and practice with them, you don't have to worry about the lesser used ones since you will probably have some notion of it. Just read what the structure/goal behind it is and everything should come to you naturally.
Depends what industry you work in, game design will employ other patterns more often than say building some saas web app.
But as long as you know the major ones well, the rest tend to be variations or extensions. Like Factory and Delegator. Delegator is essentially a Factory.
Factory is one you should know, singleton, mvc, facade etc...
Most remember it purely through repeated use. You honestly only need to know the following about any data structure or algorithm:
Here's a good google search to use: stack overflow <insert-data-structure-or-algorithm-here> applications
That should return a good list of links which should provide further information about whatever you're searching. Don't feel bad to google information, that's much better than attempting to rote memorize information.
Also: here's a good book on object-oriented design that I'd recommend which covers typical design patterns.
>> You literally get what you pay for when it comes to books.
I like these:
http://www.amazon.com/gp/offer-listing/1585009709/ref=dp_olp_used?ie=UTF8&amp;condition=used
http://www.amazon.com/gp/offer-listing/0201633612/ref=sr_1_olp_1?ie=UTF8&amp;s=books&amp;qid=1248674286&amp;sr=1-1
http://www.amazon.com/gp/offer-listing/0596528124/ref=sr_1_olp_1?ie=UTF8&amp;s=books&amp;qid=1248674320&amp;sr=1-1
https://kindle.amazon.com/work/design-patterns-elements-reusable-object-oriented/B000B10F30/0201633612
https://kindle.amazon.com/work/design-patterns-elements-reusable-object-oriented/B000B10F30/0201633612
http://www.amazon.com/gp/aw/d/B000SEGEKI
I don't know of any others from personal experience that I can vouch for. A quick search on Amazon returned this book, which has good reviews and might be worth looking into.
sure is! Funny thing about applied calculus though... like, think back to your fundamental theorem of calculus. What IS an integral? One way of thinking of it, is you're taking all these infinitely tiny pieces and adding them all up together to get a sum (your total volume in this case). For you to use integration with a parametrized function, you can take the full infinite sum that is the integral, but in real life, it's often not practical to work like that. As you pointed out, how would you parametrize a fruit? You could approximate it of course... maybe some almost-spherical ellipsoid could be an orange or something, but what about the top part? What about the bumps?
In practice, you often use what's called a numerical approximation instead. The idea is that instead of taking the 'true' integral, you just approximate it by taking a bunch of tiny (but not infinitely) tiny pieces, and then do it that way. For a lot of more complicated problems, that's the only way to do it, because it's literally impossible to solve it analytically (the equations can't be solved directly). Fluid simulations for instance, you might use 'voxels' (think minecraft) and discrete time steps (say, .01 seconds) and then march the simulation forward, solving in each little voxel at t=.01, then solve at each voxel for t=.02, and eventually, after an ungodly amount of time, you have a cool video like this! You need to use all kinds of tricks to try and make sure errors don't compound over time and that it runs as quick as possible, but the idea is that you approximate the 'true' solution by using tiny slices, kind of like you're 'almost' taking the limit to infinity. You're taking it down to the smallest pieces you can afford, given your computer budget. That's roughly how they do weather prediction and climate modeling.
so, one way to approximate the volume of a fruit, would be to do it minecraft style... get all the voxels that would be filled if you had a giant fruit in minecraft, figure out the relative scale of each voxel (say, 1mm^3 ) and then just... add up all the voxels to get your full volume.
There's a lot of ways to extract 3D data from an object though. In the field I'm interested in, you tend to either get point clouds, voxels, or (potentially, though it's much harder to extract) full 3D meshes, suitable for 3D printing or videogames or whatever. There are different ways to get the scan data in too... photogrammetry is the name for one family of techniques, the idea is that given a bunch of photos from all sides of an object, you can figure out the shape of that object in 3D space. You can see some examples of what that can look like here. There's some CRAZY math that all gets into... enough to fill a book just for the introduction, haha. And that doesn't even start to get into the current state of the art machine learning methods... but either way, the eli5 version is that you're doing an approximation. It's usually much more convenient to work with an approximate representation of the object (a 3D model or voxels or something) than it is to try and parametrize it into a form you can do calculus with. Even if you could, you're unlikely to get a function you'd be able to integrate anyway, integration gets messy when you're dealing with complicated functions. Good stuff to be thinking about though, and the fundamental ideas of what integration 'is' will need to be understood if you're going to get how approximation methods like this work, so you're on a good line of thinking.
Is this the book you're referring to: https://www.eecis.udel.edu/~cer/arv/readings/old_mkss.pdf / https://www.amazon.com/Invitation-3-D-Vision-Interdisciplinary-Mathematics/dp/0387008934/
I just want to make sure before I make a purchase.
If you are geeky about it, "The Grammar of Graphics" is a bit theory-heavy, but may be worth the dive.
After all, it's what the "gg" in the "ggplot" package is taken from.
I haven't used Origin 9 before, but from what I can see online it looks like a GUI-driven plotter. How comfortable are you with basic coding? Depending on circumstances, I use either Matplotlib or ggplot2 for data visualization at work and school.
Matplotlib is a plotting library for Python. It's standard plots can look pretty bland, but the Seaborn library helps a lot with appearance. You can handle interactivity with Jupyter Notebooks and its Jupyter Widgets.
ggplot2 is a library for R that is built around the idea of The Grammar of Graphics. Examples of some of the available plots are here. You can also use the ggthemes package to change plot appearance on-the-fly. An option for interactive plots is Plotly's ggplot2 library.
I'd be careful about saying that. See chapter 8 of An Introduction to Kolmogorov Complexity and Its Applications, for example. To get heat dissipation in processors and memory down, we'll eventually have to quit pretending that bit-banging doesn't generate waste heat!
I've been reading this book: bayesian reasoning and machine learning
The author has a pdf version available on his site.
I also read this recent nature review paper on machine learning in biology that I liked: http://www.ncbi.nlm.nih.gov/pubmed/25948244
Came at this from the opposite direction - needed to write projection calibration algorithms; this incredibly useful book supplied the linalg algorithms: https://www.amazon.co.uk/Multiple-Geometry-Computer-Vision-Second/dp/0521540518/
Yep, you've got it! Pick up Multiple View Geometry if you really want to get your hands dirty.
http://www.amazon.com/Algebraic-Statistical-Monographs-Computational-Mathematics/dp/0521864674
Whilst I agree with the sentiment, it's worth being careful about:
> If you have much more data than parameters, your posterior would heavily concentrate (see Bayesian Central Limit Theorem) around its mode
In particular, if the mode lies near a singularity of the parameter manifold (e.g. near a symmetry point of a mixture model, but much more general phenomonen exist), then the CLT doesn't really apply.
See https://www.amazon.co.uk/Algebraic-Statistical-Monographs-Computational-Mathematics/dp/0521864674
My understanding is that certain kinds of discrete random variables can be viewed as algebraic varieties.
There are also books like this.
I'd suggest a post to /r/electronics, more than 20 times the audience and a core interest in wiring shit up - which seems to be your problem here :/
On the DSP side, Open CV might be of interest to you as it implements a bunch of stuff and comes with a book.
I learned everything from this book http://www.amazon.com/Learning-OpenCV-Computer-Vision-Library/dp/0596516134 (which might be a little outdated by now). And yes, the inter-occular range is dependent on the range you want to measure. Wider separation gives you better depth accuracy, but also can require increasing the amount of image that is searched over ("max_disparities") that can slow things down, so it's a balance. The cameras should be roughly parallel and the calibration process will determine their exact orientation in order to process the images properly.
I have no idea what kinda time you are looking at but I might suggest really learning computer SCIENCE if you have a long stretch ahead of you.
Algorithms and Data types don't necessarily require a computer to understand. I would not say they are necessary to becoming a computer programmer, but if you have them everything becomes easier.
I suggest this because I am sure even if you have access to a computer that you can code on, access to that computer will be limited. There are many things you can learn that do not require a computer and will allow you to use the time you do have on a computer more productively.
There is a book called Code: The Hidden Language of Computer Hardware and Software that I highly suggest you start with.
In fact I would be happy to get you that book as a gift if you would like. If you want to PM how to do that the offer is open.
> I was just pointing out that you have to give it goals. I can't see any possible way to it to exist or do anything without having some way of turning disorder into order, and the only way to do that is give it non-random instructions. Those instructions would be the "goal," in effect.
You have to give it goals somehow, but not necessarily by specifying a utility function. You could, for example, give it a corpus of historical texts and try to have it learn human values from that (this would be a terrible idea, but definitely possible).
> But this convo we had definitely piques my interest. I'm strongly considering learning more about AI in general, on a technical level. It's too interesting not to dive in.
(Feel free to ignore everything I'm saying now.) This sounds like a very challenging prospect. At the very least you need to have a basic grasp of advanced math and a grasp of linear algebra in particular, otherwise you have no chance to understand a textbook on machine learning. If you do, then it's doable. Fwiw If you're looking for a textbook, I recommend this one.
Maybe add this book to this list of books? its modern and by the editor of the Machine Learning Journal
http://www.amazon.com/Machine-Learning-Science-Algorithms-Sense/dp/1107422221
http://www.amazon.com/Machine-Learning-Tom-M-Mitchell/dp/0070428077/ref=sr_1_3?s=books&amp;ie=UTF8&amp;qid=1397051304&amp;sr=1-3&amp;keywords=machine+learning is old but a classic.
And http://www.amazon.com/Data-Mining-Practical-Techniques-Management/dp/0123748569/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1397051336&amp;sr=1-1&amp;keywords=data+mining
Is a good by the authors of weka as well.
There are of course a lot of books but I think these are good ones for beginners.
As a book for beginning R programmers, I would recommend The Art of R Programming: A Tour of Statistical Software Design, written by Norman Matloff. As a general machine learning book, I liked this book, written by Peter Flach.
This was already published a while ago.
That link makes it look like its just getting out of draft.
I like the idea, because the other option is pretty much OpenCV or Matlab.
Nice one! CFD sure can make some beautiful images/movies. How did you make this?
I got in to CFD from a computer graphics perspective originally (Robert Bridson's Fluid Simulation book) and made an interactive solver in Java which can do some fun stuff. As an example, I made this video of convection where the density is based on the color of the fluid.
And if you want to play with the solver, it's up as an applet at http://cfb.qqnoobs.com/Fluid/. Click and drag in the screen to shoot balls of fluid!
PostGIS in Action by Regina O. Obe and Leo S. Hsu is fairly good, although could be a bit hard to start from zero without a bit of administration / sql knowledge.
It's not GLUT based, but I did create a single-file example for writing a VR app using OpenGL and GLFW/GLEW here.
And a book although it uses the 0.5 SDK, so it's a little outdated if you're working on PC.
Oculus Rift in Action (pre-order)
http://www.amazon.com/Oculus-Action-Bradley-Austin-Davis/dp/1617292192/ref=sr_1_2?s=books&amp;ie=UTF8&amp;qid=1417387255&amp;sr=1-2
If you really want to give him something I suggest, a copy of the OpenCV Cookbook,
http://www.amazon.com/OpenCV-Computer-Application-Programming-Cookbook/dp/1849513244
or maybe some IOS ebooks at pragprog.com
until recently no pixinsight book existed. however this was published last year and goes into quite a bit of detail on PI: http://www.digitalastrophotography.co.uk/Astrophotography/Home.html
also, warren keller has a book coming out within a month:
https://www.amazon.com/Inside-PixInsight-Patrick-Practical-Astronomy/dp/3319256807
design patterns are language agnostic, so it shouldn't matter which language a book opts to teach in. this book is generally regarded as a paramount resource in learning design patterns
If you're relatively new to OOD and OOP, I'd look into the Head First books. They do a great job cutting ones teeth on the topics. If that's too rudimentary for you then the GO4 book on reusable design patterns. This is the bible on design patterns for Software Engineers. As for SOLID There is a smattering of information. Basically this consists of five principles:
There's a smattering of information around the web. That should be enough to get you started.
As for implementation. One thing I've done in the past is to take a simple programming exercise, e.g. FizzBuzz and see if you can't write a solution that implements SOLID. so you can create different rules via extension. Things like that.
Design Patterns - https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented-ebook/dp/B000SEIBB8?ie=UTF8&amp;*Version*=1&amp;*entries*=0
One of the best books to own on design patterns is the GOF or "Gang of four" book. But be warned, this is not light reading, so I like to keep it for reference and use this site as a faster way to find the pattern I need. It's a less intimidating and more convenient resource for wading into the GOF patterns. SIDENOTE: I'm not a microsoft developer!
The book is still in its first edition. From the Editorial Review on the Amazon page:
> The CD-ROM works with any Java-enabled browser (Internet Explorer 4.0 and Netscape Communicator 4.0.) It includes the full text of the printed book along with the richness of hypertext links to get the most out of patterns quickly. (Two versions of the text, one for 640 x 480 resolution and one for higher resolutions, are provided.)
It's friggin' old.
Everything else changes continuously in software. It's hard to believe that there aren't a bunch of design patterns that the GoF missed or have been invented since the GoF book was written.
So I mostly taught myself programming, but i have an engineering background. For context, im working now as a game developer. What i found most helpful once i became confident with my actual problem solving skills in programming was learning programming patterns.
For me that came in the form of [this book] (https://www.amazon.ca/dp/0990582906/ref=cm_sw_r_cp_apa_fSt.Bb1A7WQ5E), which is really just a rehash of how the design patterns in this book can be applied to game development.
Basically once you're more familiar with design patterns, you'll be able to build more manageable code, and better understand others who are using the same patterns.
Not much to go on. Let's try this.
Do you understand the notion of decomposition? A well-organized program will have many functions, each of which does one thing and does it well. The higher level functions will use these as a toolkit to orchestrate more complex tasks. A program organized in such a way is easier to continue adding to even as it grows large.
Let's have an example. You have made the following lower-order functions in a hypothetical game, each of which does exactly what they advertise:
advanceToNextTurn
setPlayerMaxHealth
setPlayerSpriteGraphics
playSoundEffect
These are simple functions. Now let's make a function that uses them as a toolkit to accomplish a larger task. Let's turn the player into a werewolf.
def changePlayerIntoWerewolf():
setPlayerMaxHealth(player.currentHealth * 1.2)
setPlayerSpriteGraphics("sprites/werewolf")
playSoundEffect("audio/werewolf/howl.flac")
if(player.movementPoints < 1.0):
advanceToNextTurn()
Let's make an even higher-order function that uses this one.
def advanceMoonPhase():
if(moon.phase == 0): # full moon
if not player.inWerewolfForm:
changePlayerIntoWerewolf()
else:
if player.inWerewolfForm:
changePlayerIntoHuman()
Regarding your Roguelike - it's pretty simple as it is. I'm not sure what kind of trouble you have with it. A few hundred lines of code in a few files is not a complex program. You might consider rethinking some of the parts in terms of more stringent modelling of the game elements (for instance, shouldn't you have a Map class with all of the map data and information about which Being is standing where? Your movement methods might take the current game Map as an argument).
Books are always nice. Reading code is important, and there are many good books with excellent examples.
Most people don't have the stomach to read books like this.
Ovo?
Sticking to specific design principles in code is a recipe for pain. It's easier to adapt to pre-existing style in the case of something like UE3 than it is to adapt UE3 to specific design principles. While it's certainly good to be familiar with common patterns (Design Patterns and Code Complete are two of the more common books I see in this regard), being flexible and ready to adapt to a pre-existing code style is going to be infinitely more useful.
In that situation, you're still going to learn more on the job than in school, and that's hard to avoid.
> I've seen design patterns as a topic mentioned numerous times before; do you have any good recommendations for resources on the topic? Do they tend to be focused on the language used or are they more general concepts?
>
the 'bible' of design patterns is the book by the gang of four: http://www.amazon.com/Design-Patterns-Elements-Object-Oriented-ebook/dp/B000SEIBB8
design patterns are just that...patterns. they're high level strategies to use for particular situations. Look through /r/programming and that should lead to other web resources.
Haven't read it yet, but I believe the "Gang of Four" is somewhat of a standard for learning design patterns.
Hey, looking for two textbooks and will pay via Paypal.
&#x200B;
Book 1:Database Concepts, David M. Kroenke and David J. Auer, 7th edition, Prentice Hall, 2015ISBN-10: 0133544621, ISBN-13: 9780133544626&#x200B;
Book 2:Digital Image Processing, Third Edition, Gonzalez and Woods, ISBN 013168728X&#x200B;
Books acquired, thanks sagan1337a!
Code every day. Work on as many little interesting projects as you can. If you don't know any languages I'd suggest starting with Python, there are a million different tutorials and resources online, so getting started shouldn't be a problem.
Add to that, read some books to learn about how software development projects work, different techniques, best practices, pitfalls, etc. Here are my recommendations on books: The Pragmatic Programmer, Refactoring, Code Complete (a bit dated, but still solid), Rapid Development (slightly mis-titled, it's a good overview of different development practices), The Architecture of Open Source Applications, and Design Patterns. Code as much as you can, be ambitious, be analytical and introspective about the problems you run into, and read and understand those books too. There's a lot more you'll need to learn to become a good developer, but what I've described will give you a very strong base to build on.
Oh, and if you don't already know discrete mathematics you'll need to pick that up. I'd recommend this book.
> Unity seems to be encouraging this weird hybrid style.
This isn't actually true, there are lots of weird implementation details but there is nothing weird or hybrid about Unity's design. It's just not a data-oriented ECS. The Unity pattern is a variation on the Composite Design Pattern from this book:
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
I find more often than not that patterns are rarely well represented in books; they are almost always delve too far into implementation specific details or simply gloss over any implementation details in favor of theory. Sometimes, all I want is an ELI5 about the pattern, and let me work the rest out for my codebase.
Books on principles of coding, however, are dime a dozen. One I like in particular is Adaptive Code via C#. It gives plenty of code examples (you can download the entire working solution projects from the website given in the book) and it does a fair job of covering several patters and gives specific examples of how they apply to the SOLID principles.
Of course, there's always Design Patterns: Elements of Reusable Object-Oriented Software. This book has been one of the programmer's bibles for the past 20 years. It is a more difficult read, since it is a more theory oriented book. One thing to note is that some of the design patterns discussed in the book have been rendered obsolete by aspects of some languages and frameworks, while a number of new patterns have come to exist based on those same languages and frameworks.
I own all of Robert C. Martin's books, except for UML for Java, as well as Martin Fowler's Refactoring (the white one), PEAA, DSL and Analysis Patterns. I also have Refactoring to Patterns, Code Complete and Design Patterns (aka go4) and a few others.
I would suggest Refactoring to Patterns is the one you are looking for, but that expects you have a working knowledge of what the patterns are already (likely with your experience though you may not know them by name). I don't think that is strictly necessary but it will help you understand why you might want do do things the way being suggested in the book. The examples are in Java, but they apply to C# just as much. His site is here: https://industriallogic.com/xp/refactoring/ and he has the code up behind an online course / paywall (I have not looked into this).
In a greenfield environment, tdding up an application from a blank project Uncle Bob or Fowler's pattern books are probably better, but from the perspective of an existing codebase I think Kerievsky's Refactoring to Patterns and Fowler's Refactoring are best.
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
This book reference gets overused, but Design Patterns was a change for me in the whole way I saw code. It's not easy to get through and some of the patterns take several reads for the lightbulb to go on, but once you get a design pattern, that knowledge stays with you through any OO language, not just C++. The patterns in the book are things that you run into all the time in programming, and that spidey sense of "I've seen this before" when you're working through the design of a problem is beyond valuable. Knowing what the patterns do, and more importantly, when it's appropriate to use them, is a key differentiator especially in C++ programmers.
Technically, for C++ specifically, knowing your stuff on memory management is a highly valuable. Not just how memory management works, but what are the best practices? Who is responsible for freeing the memory if a function creates a new instance of an object and returns a pointer to it? How do you know that all references to an object are out of use once an object is released from memory? (I saw smart pointers referenced before) When do you have to zero-init alloc'd memory and why? alloc, free, calloc, realloc, new, delete, learn all of that memory management stuff.
Get an MS degree. I had a BA in Psych and went straight for MS in Comp Sci. Not every school will allow it and the ones that will will require you to take a couple of undergrad courses and pass them with B or higher.
That being said - if you still prefer to go the no degree route you're going to have somewhat of a tough time with interviews even though you may perform the job well itself. Most software engineering interviews revolve around things like how a hash map works and properties of binary trees - information you aren't usually going to get from the "build your own iphone app" type books. So I would recommend:
Good luck!
My advice is:
I was in the same boat as you 3 years ago. CS degree anddd thousands applying for the same position as me. Luckily i got a job in the end. Started applying 3 months before i finished my exam. Ended up getting a job straight after finishing my exams as a junior software developer. :)
Lots of books and videos cover it well. You can find lots here also: http://www.oodesign.com/
Also this classic book many people recommend:
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
There are a ton of books, but i guess the main question is: what are you interested in? Concepts or examples? Because many strong conceptual books are using examples from java, c++ and other languages, very few of them use php as example. If you have the ability to comprehend other languages, then:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&amp;qid=1322476598&amp;sr=8-1 definetly a must read. Beware not to memorize it, it is more like a dictionary. It should be pretty easy to read, a little harder to comprehend and you need to work with the patterns presented in that book.
http://www.amazon.com/PHP-5-Objects-Patterns-Practice/dp/1590593804 - has already been mentioned, is related directly to the above mentioned one, so should be easier to grasp.
http://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420/ref=sr_1_1?ie=UTF8&amp;qid=1322476712&amp;sr=8-1 - one of the most amazing books i have read some time ago. Needs alot of time and good prior knowledge.
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672/ref=sr_1_4?ie=UTF8&amp;qid=1322476712&amp;sr=8-4 - another interesting read, unfortunatelly i cannot give details because i haven't had the time to read it all.
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.
Read https://www.amazon.co.uk/Design-patterns-elements-reusable-object-oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&amp;qid=1462540508&amp;sr=8-1&amp;keywords=design+patterns
So many things in this book are immediately noticeable in many of the large frameworks. Model-View-Controller is a really common pattern.
Actually the biggest things to learn for me were testing related however. Test-driven development is an awesome habit to pick up - really changes how I design code.
While it's not specifically game related this book has been an excellent resource for me as far as patterns go.
Also, flyweight rox!
The Data Warehouse Toolkit: The Complete Guide to Dimensional Modeling (Second Edition)
Design Patterns: Elements of Reusable Object-Oriented Software
Good stuff.
Personally I'm very partial to Design Patterns: Elements of Reusable Object-Oriented Software. I see Java more and more as a software engineering, rather than a programming language. You can do programming more effectively in Python/Jython or (J)Ruby, but Java for me still is king for developing type-safe, robust libraries and unit testing.
You might also want to read up on Eclipse or another decent IDE. Eclipse reduces the amount of monkey typing that all Java developers must endure dramatically with things like templates, getter/setter generation, delegate method generation etc. Since the editor parses the code as you type and keeps an AST in memory, refactoring support is excellent and you'll spend less time worrying about minor design issues when starting a new project. Code is compiled on the fly so startup times are minimal. It's also able to produce very descriptive and useful information about any errors you might have in your code (unlike GCC, for instance:)
If you want to know a bit more about how the JVM itself works, read The JavaTM Virtual Machine Specification, Second Edition which is online and free. It'll give you a bit more insight into why some crappy things are as crappy as they are (backwards compatibility with Java 1.1). Read books that are recent enough to include language features of 1.5 and 1.6, such as static imports, enums, generics, varargs and so on, and decompile some Java code to see how the compiler implements them.
You might try to fit your work in design patterns ( start with the gang of four ;) ) and code the structure UML style.
Take one of your old projects and use umbrello (only for linux) to port it to UML. Check if you can make it more simple,better or fit in a design pattern. And don't go to the other edge -in this way of programming you get clean and organized structure but you need more time (and sometimes code) to get a result.
Also, get a task manager like taskfreak and write a todo list with deadlines.
And as dmazzoni advised: use github.
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.
cant believe nobody has mentioned design patterns yet.
Gang of Four is the standard for design patterns.
As someone making the switch (I start my new Developer role later this month):
Well, even with your disclaimer, I would still strongly recommend that you give CC2 a readthrough. Don't worry about understanding every bit of it, but get a lay of the land.
Other books you should read include:
http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X/ref=sr_1_1?ie=UTF8&amp;qid=1405474488&amp;sr=8-1&amp;keywords=algorithms
http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?ie=UTF8&amp;qid=1405474502&amp;sr=8-1&amp;keywords=head+first+design+patterns
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_2?ie=UTF8&amp;qid=1405474514&amp;sr=8-2&amp;keywords=gang+of+four
I would read them in that specific order.
Here's pretty much your most basic flow for problem 3:
To troubleshoot, use a debugger (Eclipse's builtin is nice). If you feel it's taking too long, break the program's execution and check its state. Is the loop counter about where it should be? Are the found divisors plausible? Is the loop end target plausible? Set a breakpoint on the first line inside the loop and keep stepping through (either one line at a time if you like, or just hit 'resume' and it will break again at the top of the next loop iteration).
I learned Java throughout college, as it was the primary teaching language. Honestly, the best way to learn is just to WRITE CODE. Solve problems that you don't know how to solve. Invent random things that are useful to you. Your code doesn't have to be perfect when you're learning (and it definitely won't be!), and what is important is that you constantly look for ways to improve. I want you to look back on code you've written a year ago, and think that it's absolute crap - that will show that you are learning and improving.
Somewhat counter-intuitively, the best resources are books! I'll list some recommendations below.
Keep these principles in mind:
Once you start getting a feel for Java, which I think you might be already, Effective Java is the book. You probably won't need any other resource for Java itself.
If you need help with something, Reddit is a great place, but Stack Overflow is the programmer's mecca. The best resource on the web for just about everything software, and their sister sites cover other topics, from IT/sysadmin to gaming.
The game piece example is about using singleton to, yes, conserve memory, with simple data types. For instance, you'll note that ruby itself, analogously, uses it with integers.
101is always exactly the same object in ruby (which is necessarily immutable for that reason; in general, singletons that have any mutable state at all are going to give you nightmares, especially under concurrency). (You can verify this checking101.object_id, always the same for any101anywhere in a program execution. This is not true for string"101", which is of course also mutable).In the "Gang of Four" book, which introduced the notion of "design patterns" in programming as well as the "singleton" pattern specifically -- I think this particular pattern would actually be identified as the "flyweight" pattern, rather than "singleton", although it's implementation might in this case be in terms of singleton.
I probably wouldn't be likely to actually implement a chess game that way. I think the "flyweight" pattern is pretty specialized in contemporary programming, where RAM is a lot more bountiful compared to when the GoF was writing. The times you need to conserve RAM this way and it's worth the added complexity are probably rare (although probably not never ever encountered).
Design Patterns
The Art of Computer Programming
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.
Try http://codingame.com. Pretty fun in short bursts. Books are still good resources. Try out https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612. Do you like playing games? Try making a crude remake of the simplest game you enjoy. Maybe a poker clone...then add an AI.
I'm surprised Design Patterns: Elements of Reusable Object-Oriented Software isn't on the list. Old (1994), but gold.
Does anyone know what would be best to prepare me for interviews for new-grad interviews that'll probably open during Fall 2019? I don't think it's that important to have side projects as I have internships/experience under my belt, so I just want to be studying/enhancing the foundation I have. I currently own CTCI and The Algorithm Design Manual. I'm planning on getting the Gang of Four Design Patterns, but I'm not 100% yet. Anyone know any good resources for System Design? Any feedback on how should approach this preparation? I know it's super early, but better early than late.
If you were serious about wanting some deep as-you-go knowledge of software development but from a Pythonic point of view, you cannot go wrong with following a setup such as this:
Mark Lutz writes books about how and why Python does what it does. He goes into amazing detail about the nuts and bolts all while teaching you how to leverage all of this. It is not light reading and most of the complaints you will find about his books are valid if what you are after is not an intimate understanding of the language.
Fluent Python is just a great read and will teach you some wonderful things. It is also a great follow-up once you have finally made it through Lutz's attempt at out-doing Ayn Rand :P
My recommendation is to find some mini projecting sites that focus on what you are reading about in the books above.
Of course this does not answer your question about generic books. But you are in /r/Python and I figured I would offer up a very rough but very rewarding learning approach if Python is something you enjoy working with.
Here are three more worth adding to your ever-increasing library :)
If you finish up the other books, you could read Design Patterns and The Pragmatic Programmer. There will be some overlap with the first two books I mentioned, but I think it can be helpful to read about the same topics from different points of view. I would probably read Clean Code and The Pragmatic Programmer straight through. The other two can be used more like reference books. Although, be sure to practice the design patterns you learn from the reference books.
There are programming exercises that you can use to practice patterns. Look up coding katas and see what you can find. Start with Gilded Rose. There are multiple ways to refactor this code, so it's a good one to practice. Here's another one.
First Advice! Don't listen to high school guidance counsellors.
You require certain high school courses to qualify for College or University programs. What you want (ideally) is a 3 Year University Bachelor's Degree in Computer Science with a Minor in Game Development. Figure out which schools you're interested in and what they require for admissions to their programs.
You're probably hoping to start making games now though, so I'll give you some advice on that.
Try to get a copy of this book: http://gameenginebook.com/
It's kind of a heavy book, both figuratively and literally, but it'll teach you everything about how a video game works. Even if you're not going to be building this or that part of a game, it's important to know how it all works and fits together.
This YouTube Channel Extra Credits has a lot of great video articles on game design and development, and links to other channels.
You can find a ton of guides on YouTube for computer programming, game design, 3D modelling, music, etc. The key word to search for is Tutorial.
Once you've learned how to program computers, you should read this book to learn how to program computers well: Design Patterns: Elements of Reusable Object-Oriented Software
It's a pretty old book, but that's because nobody has had reason to update it; it's just that good. That said, a smart fellow released a free web-based followup book for Game Developers here: http://gameprogrammingpatterns.com/
If you want to focus on Game Design I'm a big fan of Raph Koster so here's his book too: http://www.theoryoffun.com/
I guess the rest is up to you. Any specific questions?
Sorry but there's no cheat sheet and no reasonable way of making one. C++ is a rather large and complex language laid atop C, which is effectively laid atop an assembly language, which is compiler manufacturer and target platform dependant.
The best way to learn C++, or any programming language for that matter, is to use it, learn from your mistakes, and of course researching and reading everything you can. And of course, have fun with it!
Many popular books exist covering C++ things. Here are a couple good starter ones, in my opinion:
A couple popular C++ sites:
If you're simply starting to learn programming, start small. I suggest beginning with an object-oriented scripting language like Ruby, Python or Javascript. Most concepts will transfer to C++, but beware that the syntax will not - you will quickly see the difference!
Design Patterns is a land-mark work published in 1994 that captures some recurring, useful object-oriented designs.
http://pixelshaders.com/
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
http://mitpress.mit.edu/books/history-modern-computing
http://c2.com/cgi/wiki?ReallyValuablePages
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf
http://www.haskell.org/haskellwiki/Research_papers/Functional_pearls
http://www.glprogramming.com/red/
http://wiki.lesswrong.com/wiki/Sequences
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.
You mentioned Robert Sedgewick. His book, Algorithms and his online courses are highly recommended. And he uses Java in them.
http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X
http://algs4.cs.princeton.edu/home/
For object-oriented design the Head First books are great. It also worth to have the classic book Design Patterns: Elements of Reusable Object-Oriented Software.
http://www.amazon.com/dp/0201633612
I also recommend the books Code Complete, and Clean Code, they are great.
You probably don't need extensive knowledge of data structures for mobile apps, but I ALWAYS encourage learning data structures! Knowing what structures are available and when to use them is a bit like being a programmer super-hero and one of the things that really sets apart the self-taught hackers from the top tier engineers and scientists.
It's not a course, but I always love to plug my professor's book Open Data Structures. He's made it freely available in many different languages with code samples in multiple languages, and it's a really good read.
One thing I would highly recommend before getting into the mobile space, however, is looking into design patterns. The fundamental book on this is Elements of Reusable Object-Oriented Software by the Gang of Four, but there are some other ones I've found which are pretty handy. Game Programming Patterns is freely available, but it is a bit domain specific. It really nicely details a lot of patterns, however. JavaScript Design Patterns also really nicely details them and is also freely available.
Design Patterns: Elements of Reusable Object-Oriented Software (Gang of Four / GoF's book) is the bible of OO design pattern.
You can also find info here: http://c2.com/cgi/wiki?DesignPatternsBook
You can easily find info / samples / illustrations of the various design patterns if you just Google their name one-by-one though.
Interview Cake
It is paid.
It is prepares people for coding interviews. Those will have the fundamental issues that you will need in your courses. It has pretty top notch for explanations and broad coverage. Many languages. High quality product. If you are having issues paying for it - maybe some of your coding friends might be interested in splitting the bill. You'll have to work out how ahead of time. Definitely sign up for the weekly email and do the problem.
&#x200B;
The other issue you may have is that you don't understand how the code fits together. Specific lack of understanding on how the design patterns work and fit together into architectural patterns.
Design Patterns: Elements of Reusable Object Oriented Programming
There are less than 30 of them. You should know them by pseudocode. Know which ones apply to which types of languages. It might take you awhile to really learn them. Use Anki to help review them on the toilet.
&#x200B;
The other aspect is software architectural design patterns. I don't have a book that I would recommend for that one. Not because I couldn't find one, I just haven't reviewed enough literature to point you in the right direction. There might be 20. There might be less.
&#x200B;
&#x200B;
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
How about a new language? Or writing software rather than web stuff?
After doing webdev for a while I got in to offline Java (software) development. Aside from helping me tighten my grasp on real OOP, it also caused me to shift/alter some of my design patterns. Java itself can be extremely cumbersome to write, but the process of doing so definitely made me stop and re-think exactly HOW much I want to leverage the flexibility of other languages.
Writing Java also lead me to read books, from which I took lessons I could apply to other languages. These books in particular were helpful:
http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.barnesandnoble.com/w/data-structures-and-algorithms-in-java-robert-lafore/1100840388?ean=9780672324536&amp;itm=1&amp;usri=9780672324536
Obviously I'm just using Java as an example. If you already write Java, or feel great about your understanding of OOP, perhaps try a functional programming language? Lisp(Clojure)? Scala? The performance of some of these languages is really wild, and I'd think it would be possible to leverage their speed when working on large SAAS projects.
Anyways, to each their own. Obviously the other comments here have plenty of good suggestions. I know I certainly didn't regret getting familiar with SASS. And I could probably stand to spend time forcing myself to get more proficient with my editor. Right now I use Sublime Text 2, and I could either make sure I'm using all the proper key binds for traversing/manipulating text OR just go boss mode and make the switch to vim. Or even bite the bullet and use an IDE (http://www.jetbrains.com/).
Best of luck!
Yeah I have read around 70%-80% of all YDKJS books combined .
By the way just in any case you find anything interesting and helpful (but for also copy pasting this list in the future) here are the books-site tutorials-docs that I am reading-have read-plan to read-follow :
web dev road map
htmldog
www.javascript.info
css in depth (manning)
eloquent js
YDKJS (all books)
HTML5 for masterminds
dom enlightenment
high performance images
web performance in action
reliable javascript
building progressive web apps
http: the definitive guide
learning http 2
cracking the coding interview
javascript data structure and algorithms (be careful,not a good choice, it has a lot of mistakes but I find it concise)
professional git
vs code docs
Using SVG with CSS3 and HTML5
Interactive Data Visualization for the Web
refactoring ui
figma docs
react docs
redux docs
vue docs
webpack docs
clean code
design patterns
web components in action
Inkscape: Guide to a Vector Drawing Program
and many more to come .
First note that Career/Job/Market is quite different from Knowledge/Intellectual satisfaction. So you have to keep "earning money" separate from "gaining knowledge" but do both parallely. If you are one of the lucky few who has both aligned in a particular job, you have got it made. Mostly that is never the case and hence you have to work on your Motivation/Enthusiasm and keep hammering away at the difficult subjects. There are no shortcuts :-)
I prefer Books to the Internet for study since they are more coherent and less distracting, allowing you to focus better on a subject. Unless newer editions are reqd. buy used/older editions to save money and build a large library. So here is a selection from my library (in no particular order);
Is this the book, "Design Patterns", that you were referencing?
The gang of four book.
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
...continued...
> Test plans - When you apply for QA roles, you'll almost certainly be asked "how would you test ____?". The correct answer is to be methodical. Don't just spew out a stream of test cases as you brainstorm them. Understand the different scopes (unit, functional, integration, maybe end-to-end) and what the goals of each is, and how they differ. Understand that there are different areas of testing like boundary, happy path, special cases (null, " ", 0, -1), exceptions, localization, security, deployment/rollback, code coverage, user-acceptance, a/b, black box vs white box, load/performance/stress/scalability, resiliency, etc. Test various attributes at the intersection of a compenent and a capability (borrowed from the book How Google Tests Software), and I believe you can see a video that goes into this called The 10 Minute Test Plan. Understand how tests fit into your branching strategy - when to run bvts vs integration vs regression tests.
> Test methodologies - Understand the tools that make you an efficient tester. These include data driven tests, oracles, all-pairs / equivalency class, mocking & injection, profiling, debugging, logging, model-based, emulators, harnesses (like JUnit), fuzzing, dependency injection, etc.
> Test frameworks - Knowing all the tests you need to write is good, but then you have to write them. Don't do all of them from scratch. Think of it as a system that needs to be architected so that test cases are simple to write, and new functionality is easy to implement tests for. I can't recommend any books for this because it's something I learned from my peers.
> Test tools - Selenium / WebDriver for web ui, Fiddler for web services (or sites), JUnit/TestNG, JMeter (I have to admit, I don't know this one), integration tools like Jenkins, Github/Stash, git/svn.
> System design - As you're entry-level, this may not be a huge focus in an interview, but know how to sensibly design a system. Know which classes should be used and how they interact with each other. Keep in mind that the system may evolve in the future.
> Whiteboarding - Practice solving problems on a whiteboard. The process is more than just writing the solution, though. This is the process I follow (based loosely on the book Programming Interviews Exposed):
Resources:-
> Learning to test:
> Learning to interview:
> Learning to program:
> Miscellaneous
> What sort of skills should I really hone? I realize I gave you a ton of stuff in this post, so here's a shorter list:
> Examples of projects that make you look valuable
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
http://www.amazon.com/Coding-Standards-Rules-Guidelines-Practices/dp/0321113586
Also if you want something really challenging:
http://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043
http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
Free below:
https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html
I would assume digital design has to do with software planning, i.e. making UML diagrams and such. You will also most likely be expected to know the basics of design patterns, and you should check out this book.
Get the original book, at least skim it and remember the type of problems it helps you fix. You don't need to memorize it, but it also just helps thinking about software more abstract:
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Also as you said, there are a lot more now. A lot of new trends came and went since then. But this is a really good foundation. On top of that you can read up on whatever is relevant for your projects.
No, it isn't. Wikipedia is, like usual, because it's written by people who learned what MVC means from random frameworks that also get it wrong.
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
If you didn't like the style of Head First, the GoF book is a more formal option.
This one is one of the most (if not the most) popular book of C++ design patterns.
ggplot is an implementation of the ideas from "Grammar of Graphics". It is so much more than just pretty looks.
I kind of see your point, but I don't completely agree. As I said already, I know something about active research in this field: enough, as a matter of fact, to be able to read these books
https://www.amazon.com/Understanding-Machine-Learning-Theory-Algorithms/dp/1107057132
https://www.amazon.com/Foundations-Machine-Learning-Adaptive-Computation/dp/0262039400/
https://www.amazon.com/High-Dimensional-Probability-Introduction-Applications-Probabilistic/dp/1108415199/
However, as most researchers, I mostly focus on my specific subfield of Machine Learning. Also, every now and then, I'd like to read something about my job, which however doesn't feel like work (even a professional football player may want to kick a ball for fun every now and then 😉). Thus, I was looking for some general overview of Machine Learning, which wouldn't be too dumbed down, according to experts (otherwise I wouldn't have fun reading it), but which at the same time wasn't a huge reference textbook. After all, this would be just a leisure read, it shouldn't become work after work.
That's why I asked here, rather than on r/LearnMachineLearning. However, if other users also feel I should ask there, I will reconsider.