Best computers & technology books according to redditors

We found 39,785 Reddit comments discussing the best computers & technology books. We ranked the 9,745 resulting products by number of redditors who mentioned them. Here are the top 20.

Next page

Subcategories:

Computer & video game strategy guides
Computer & technology certification guides
Computer science books
Web development & design books
Networking & cloud computing books
Operating systems books
Computer programming books
Programming languages books
Computer software books
Computer graphics & design books
Internet & social media books
Databases & big data books
Computer hardware & DIY books
Business technology books
Mobile & wireless computing books
Computer security & encryption books
Digital audio, video & photography books
Computer history & culture books

Top Reddit comments about Computers & Technology:

u/Bizkitgto · 7876 pointsr/learnprogramming

I'd start with Harvard's CS50 on edx, it's the best course you'll find anywhere bar none. The instructor, Dave Malan is world class. Check out CS50, and the sub r/cs50 has a lot of like minded people like you. (Note: this course is free)

Stackoverflow is your friend where you can ask any question you have or bounce ideas off of others.

Learn Java OOP (here is an excellent course): Java MOOC

Free Code Camp for web development

Build your own operating system: NAND2TETRIS

Cave of Programming : All kinds of programming

Open Source Society University: This is a solid path for those of you who want to complete a Computer Science course on your own time, for free, with courses from the best universities in the World.

r/arduino for some embedded programming fun!

.....and of course for anything under the sun: https://www.edx.org/ & https://www.coursera.org/



For BSD: https://www.freebsd.org/

For Linux: https://www.archlinux.org/



For x86 assembly: http://opensecuritytraining.info/IntroX86.html [How far down the rabbit hole do you want to go?]

***

Edit: Wow, my first Reddit Gold!! Thank-you so much kind people!!

Edit2: Colt Steele has a good web dev course and is highly recommended to do in parallel with freecodecamp

Edit3: The MIT Challenge
is Scott Young's blog on how he completed the entire 4 year MIT Computer Science curriculum in 12 months

Edit 4: The Rails Tutorial by Michael Hartl is the Bible for learning Ruby on Rails

Edit 5: For deeper knowledge of OOP check out Sandi Metz’s POODR

Edit 4: The Bible for C Programming: K&R

u/D3FEATER · 699 pointsr/IAmA

The exact four books I read are:

Learning Obj-C

Learning Java

iOS Programming: The Big Nerd Ranch Guide

Android Programming: The Big Nerd Ranch Guide

However, I would now recommend learning Swift instead of Obj-C. At the time when I was looking into iOS books, good books on Swift were few and far between.

u/ilknish · 482 pointsr/learnprogramming

Code: The Hidden Language of Computer Hardware and Software.
It may be a bit more lower level than you're looking for, but it'd be a great foundation to build off of.

u/batmassagetotheface · 383 pointsr/learnprogramming

I always recommend this book called 'Clean Code'
It details a collection of techniques to keep your code readable and maintainable.
In general use good variable and method names and use more, shorter methods where appropriate

u/[deleted] · 326 pointsr/AdviceAnimals
  • codecademy (not that great, don't rely on it too much)
  • HTML & CSS - Jon Duckett
  • use the MDN website for help, never use w3schools

    Above all, make shit. Fuck tutorials, being held by the hand just takes longer. Copy other websites relentlessly, recreate everything you see. Doing > reading

    EDIT Lemme link y'all up.

  • Codecademy - your brochure into the world of web development
  • Learn to code HTML & CSS - extended brochure
  • HTML & CSS - beginners guide (it's really pretty)
  • Codepen.io - your new inspiration
  • MDN - your new pokedex

    Extra credit

  • A List Apart - cool articles
  • A Book Apart - short, in depth books on various topics
  • Hack Design - design lessons

    ** JavaScript not included.
u/samort7 · 257 pointsr/learnprogramming

Here's my list of the classics:

General Computing

u/radium-v · 243 pointsr/IAmA

I'm going to be brutally honest here, and I'm probably going to get down-voted, but I'm not impressed with the underlying code for the project. I don't even know where to begin.

You're obviously passionate about Javascript, but runtime engines and best practices have changed dramatically in the last few years. Some things that stick out could easily be chocked up to coding style or preference, but when those preferences aren't well-adjusted to current-day standards, it leads to a perpetuation of those bad practices and hinders the growth and evolution of web development overall.

I'm posting this here, instead of on Github, because these aren't quite bug reports. I'd be more than happy to contribute though.

  1. Syntax and readability are more important than shortcuts.

    Cutting corners in the interest of character count is useless. It's better to be able to read the code than to have to interpret it line-by-line.

    For hinting, I recommend JSHint. It'll be nicer than JSLint, but it'll still likely hurt your feelings.

    Here are some JSHint errors/warnings that popped up:

    > The body of a for in should be wrapped in an if statement to filter unwanted properties from the prototype.

    > Expected an identifier and instead saw 'arguments' (a reserved word).

    > Expected a 'break' statement before 'case'.

    A lot of syntax errors can be solved by linting or hinting, and following a style guide. Here's Google's Javascript Style Guide. You'll find that most projects on Github follow the same code conventions, and for very good reason. When you make your code consistent and readable, other developers will be more likely to like you and contribute to your projects.

  2. Read Douglas Crockford's Javascript: The Good Parts and Nicholas Zakas' Maintainable Javascript.

  3. Use an AMD-style, modular system like Require.js or Yahoo Module Pattern because Global variables are evil. The basic idea behind a modular system is that every piece of functionality is broken down to its basic form, and no less. It helps to keep things organized. Even if you choose not to use a framework, following a trusted organizational pattern is a good idea. Consistency is key.

  4. Check out Backbone.js or Underscore for data manipulation.

    I really like the project, but the code is unwieldy and confusing.
u/MrPhi · 215 pointsr/InternetIsBeautiful

You don't need school to learn how to do that. It's true for most things in life but it is even easier with computer science.

Want to learn C ? No school will ever teach it better than the book The C Programming Language (also called K&R) by Brian Kernighan and Dennis Ritchie.
Want to learn C++ ? You should start with C or C# or Java and then go for Programming: Principles and Practice Using C++ by Bjarne Stroustrup.
Want to learn Python ? Go to python.org and pick a tutorial.
Want to learn Javascript ? Eloquent JavaScript by Marijn Haverbeke.
Want to learn HTML5 ? Maybe have a look at diveintohtml5.info or W3Schools
Want to learn Java ? The Java Programming Language by Ken Arnold or Head First Java by Kathy Sierra.

You need two things, time and will. You'd be surprise how easy it is to learn all those things if you like it and if you have a dream project.

edit: Woh, thanks for the gold. :D

u/Waitwhatwtf · 208 pointsr/learnprogramming

When you learned Spanish, did you start having full-fledged conversations? Just walked into class on day one and boom: "tango el gato los pantalones"?

If I were a betting man, I'd say no.

They gave you a book for grammar, a dictionary for words, and taught you ways to pronounce and express sounds that aren't in English.

Most videos (whether they mean to or not) are presented in such a way, that you need to know Spanish before you start learning Spanish. Sometimes you get lucky, but most are for the already initiated.

I usually recommend this book for the uninitiated. It's quite descriptive, very short, and covers a large amount of topics briefly enough to get one interested in the language (or in programming in general). This is your grammar book.

Here's your dictionary.

The last thing you need is to use the language. In the case of programming, solve a problem. If you want to make games; learn the basics of Java grammar, and make a guess-the-number game. Then work up to a text adventure. Then figure out how to do pong, then breakout, then tetris, then Mario.

Software development isn't about knowing everything. It's about knowing what you don't know and learning what you need to learn to solve the problem.

u/UghWhyDude · 199 pointsr/worldnews

Ditto - I have a Eastern Economy Edition of K&R when I took up learning C as a hobby. When I looked up the price for the same on the US version of Amazon, the price comparison was startling.

[Here's the US paperback version, priced at about 53 USD according to Amazon, i.e. 3,554 Indian Rupees. Of course, the cheapest one you can still get new is about USD 15 or so dollars. ] (https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1474085789&sr=1-1&keywords=kernigan+and+richie)

Here's the Indian "Eastern Economy Edition", paperback, of the same book, identical in every single respect, priced at a whopping 194 rupees, or about 3 dollars.

For the money you'd be shelling out, it'd be cheaper for you to buy a brand new copy of the book from an Indian bookstore and have it shipped out to you (possibly even through an express courier like DHL or FedEx) in the US than just buy the book in the US outright.

u/_a9o_ · 188 pointsr/cscareerquestions

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.

u/HeterosexualMail · 187 pointsr/programming

We did something similar as well. The labs were tons of fun. I remember having to run a couple dozen lines of code through the CPU cache on a test once, including some sneakery of using code as data at one point. I do appreciate having done it, but I'm not sure how much practical lasting value that really contributed.

That said, for those who are interested in this there is The Elements of Computing Systems: Building a Modern Computer from First Principles, more commonly known as "NAND to Tetris".

Petzold's Code is excellent as well.

Edit: Actually, while I've suggested those two let me throw Computer Systems: A Programmer's Perspective into the mix. It's a book we used across two courses and I really enjoyed it. We used the 2nd edition (and I have no issue recommending people get a cheaper, used copy of that), but there is a 3rd edition now. Being a proper text book it's stupidly priced (you can get Knuth's 4 book box set for $30 more), but it's a good book.

Anyone have suggestions similar to that Computer Systems's text? I've always wanted to revisit/re-read it, but could always used a different perspective.

u/_dban_ · 168 pointsr/programming

Isn't this argument kind of a strawman?

Who says that self-documenting code means absolutely no comments? Even the biggest champion of self-documenting code, Uncle Bob, devotes an entire chapter in Clean Code to effective commenting practices.

The idea of "self-documenting code" is that comments are at best a crutch to explain a bad design, and a worst, lies. Especially as the code changes and then you have to update those comments, which becomes extremely tedious if the comments are at too low a level of detail.

Thus, while code should be self-documenting, comments should be sparse and have demonstrable value when present. This is in line with the Agile philosophy that working code is more important than documentation, but that doesn't mean that documentation isn't important. Whatever documents are created should prove themselves necessary instead of busy work that no one will refer to later.

Uncle Bob presents categories of "good comments":

  • Legal Comments: Because you have to
  • Informative Comments, Clarification: Like providing a sample of a regular expression match. These kinds of comments can usually be eliminated through better variable names, class names or functions.
  • Explanation of Intent
  • Warning of Consquences
  • TODO Comments
  • Amplification: Amplify the importance of code that might otherwise seem consequential.
  • Javadocs in Public APIs: Good API documentation is indispensable.

    Some examples of "bad comments":

  • Mumbling
  • Redundant comments that just repeat the code
  • Mandated comments: aka, mandated Javadocs that don't add any value. Like a Javadoc on a self-evident getter method.
  • Journal comments: version control history at the top of the file
  • Noise comments: Pointless commentary
  • Closing brace comments
  • Attributions and bylines
  • Commented out code
u/YuleTideCamel · 162 pointsr/learnprogramming
  • Clean Code is a really good programming book. It's technical in that it gives you best practice, but you don't need a laptop or to code to follow along, you can just absorb the information and follow along with the simple samples (even if it's not your primary coding language).

  • The Clean Coder is a great book about how to build software professionally. It focuses on a lot of the softer skills a programmer needs.

  • Scrum: The Art of doing twice the work in half the time is a great introduction to scrum and why you want to use it. Agile (and scrum in particular) can have a major improvement on the productivity of development teams. I work for a large technology company and we've seen improvements in the range of 300% for some teams after adopting scrum. Now our entire company is scrumming.

  • Getting Things Done has personally helped me work more efficiently by sorting work efficiently. Having a system is key.

  • How to Win Friends and Influence People I often recommend devs on our team read this because it helps with interpersonal communication in the office.

  • Notes to a Software Tech Lead is a great book so you can understand what a good lead is like and hopefully one day move up in your career and become one.

u/TheAmazingSausage · 128 pointsr/androiddev

Android team lead here, I've been working with Android commercially since 2009 (before Android 2.0 was released) and have worked at, or done work for, some big companies (Mozilla, Intel, Google, HTC...). I was in a very similar situation to you in that I was a web development and was bored, I'd been playing with Android in my spare time; I got my first break by volunteering to do an android app at the company I worked for, and went from permanent employee to contractor fairly quickly after that and have been doing it ever since.

First thing to say is that if you can get your currently company to pay you to learn android and stay with them, that's a win win for both parties (you get to learn something new without a drop in salary and don't have to interview and they don't lose a good member of staff).

In terms of moving company, I don't know where you are based, but here in the UK I often see junior Android contract roles coming up for £200-300 a day. Failing that it's just a case of applying for lots of poisitions and really knowing your stuff.

What I would look for in a junior is to have read, understood and put in to practice Clean Code (https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) and Design Patterns (https://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124). I would expect you to have a good understanding of basic Java and OOP; a working understanding of MVP or MVVM (https://news.realm.io/news/eric-maxwell-mvc-mvp-and-mvvm-on-android/, https://www.linkedin.com/pulse/understanding-difference-between-mvc-mvp-mvvm-design-rishabh-software); understand threading; know about all the major parts of Android (Services, Broadcast receviers, Activities, Fragments etc); know how to write a custom view; be able to efficiently design a layout in XML and correctly apply styles and themes; understand the support libraries - what they contain, why they exist and what they are used for (and also when you don't need them); understand the difference between unit testing and integration testing and know what makes for a good test; the Gradle build system is a really nice way of defining your project build - knowing the fundamentals is essential.

A few of the main libraries I'd expect you to know and have used would be OkHttp (https://github.com/square/okhttp), Retrofit (https://github.com/square/retrofit), Butterknife (https://jakewharton.github.io/butterknife/), Picasso (https://square.github.io/picasso/) or some other image loading library, GSON (https://github.com/google/gson) or Moshi (https://github.com/square/moshi) or some other json parsing library

If you want to level up then there are loads of advanced topics surrounding Android. Any of these following topics will take a while to learn, but will be worth it and will look good in interviews and on you CV:

u/Any0nymouse · 125 pointsr/HowToHack

Actually, start with some programming, then move on to "The Art of Exploitation" it's the best book on "hacking" I've ever used...

u/falcojr · 103 pointsr/programming

If you're really serious about learning, I HIGHLY recommend the book Code: The Hidden Language of Computer Hardware and Software. It's basically a book that 'builds' a computer from the ground up, starting with simple morse code type stuff through the wire, and each chapter just keeps building until you get to assembly and some higher level language stuff at the end. You do have to think through (or glaze over) some stuff in a few chapters, but it's a very eye opening book.

Edit: Grammar

u/CrazedToCraze · 98 pointsr/ProgrammerHumor

+1, don't just circle jerk and pretend you're above learning patterns before you even understand why they exist. They can be abused, but they exist for good reasons.

I strongly recommend going over Head First Design Patterns to anyone interested.

u/phpdevster · 87 pointsr/webdev

You need to build up a foundational set of programming skills. Frameworks and libraries are important to know, but not as important as knowing how to program. The difference between a program/website/webapp that works, and a program/website/webapp that works AND has sensible code, is significant to a company. I've seen the simplest of features take weeks to implement in very poorly written code bases. This is valuable and expensive time that could have been spent building other features.

Companies are sensitive to this because very few companies are immune to the effects of poorly written and maintained code bases, so they are going to ask you code design questions and even have you do live programming challenges to see how think about the problem, and whether the design of a solution is important to you, or whether you're content to just shit out any old solution that works and move on.

To start, with, I would familiarize yourself with the basic mechanics of the language by reading the You Don't Know JS series: https://github.com/getify/You-Dont-Know-JS/tree/1st-ed

Next, I would read Clean Code by Robert Martin. It's based in Java, but the general principles are the same.

Next, I would read Refractoring: Improving the Design of Existing Code (2nd edition - which is JavaScript based). You can read the Java-based 1st edition for free.

Finally, I would read A Mostly Adequate Guide to Functional Programming.

Yes, it's a lot of reading, but these books will help you think about your code design choices, and in combination with practice, will help you write better code. But of course there is no substitute for practice. The more you write code, the better you'll be at it. The resources I linked to are just guides, not magic bullets.

In terms of other things that are necessary to learn, you'll need to learn how to use git (not to be confused with GitHub). Git is basically the industry standard version control system. You don't have to be an expert at it, but you do need to know the basics of it.

You're also going to want to get familiar with the basics of node and npm, because even doing front-end work, you'll be relying on 3rd party packages, and running builds, all of which are managed through node and npm (or yarn).

u/PM_ME_YOUR_MAKEFILE · 75 pointsr/learnprogramming

CODE by Charles Petzold is the book to read to understand computers at a base level. It literally starts at a single bit and moves all the way up the stack. I cannot recommend this book enough for someone starting out.

u/cogman10 · 75 pointsr/learnprogramming

HTML and CSS are pretty simple, I would spend almost no time reading about them (Unless this is for some sort of job interview) for the most part you will just be googling "How to I make round borders" until you can do it by rote memorization.

JS, on the other hand, is a tricky beast. I would spend a majority of my time learning not just how to write javascript, but how to write good javascript.

javascript the good parts and Javascript garden is where I would start out learning. Javascript is easy to write, but hard to write well. You need to follow strong conventions otherwise your code will end up looking like spaghetti right quick and in a hurry. If you start playing around with the language, I would suggest using JSLint to make sure you aren't doing anything stupid.

After getting a good strong base in javascript jquery shouldn't be too hard. It is just a javascript library. perusing through the docs and getting a feeling for what it can do is probably all you really need. Just like any library you've used. You didn't learn all of the .Net framework, rather you would google and lookup specifics as you needed them. That is much the way you are likely to use jQuery. It can do a lot and you don't need to know everything it can do to use it effectively.

In short, javascript is where the traps are. The other things you mentioned are "I'm going to google this anyways" so I wouldn't really spend a large amount of time learning them.

u/koeningyou666 · 73 pointsr/netsecstudents

In my opinion; every book in this bundle is a bag of shit.

Here's a list of reputable books, again in my opinion (All links are Non-Affiliate Links):

Web Hacking:

The Web Hackers Handbook (Link)

Infrastructure:

Network Security Assessment (Link)

Please Note: The examples in the book are dated (even though it's been updated to v3), but this book is the best for learning Infrastructure Testing Methodology.

General:

Hacking: The Art of Exploitation (Link)

Grey Hat Hacking (Link)

Linux:

Hacking Exposed: Linux (I don't have a link to a specific book as there are many editions / revisions for this book. Please read the reviews for the edition you want to purchase)

Metasploit:

I recommend the online course "Metaspliot Unleashed" (Link) as opposed to buying the book (Link).

Nmap:

The man pages. The book (Link) is a great reference and looks great on the bookshelf. The reality is, using Nmap is like baking a cake. There are too many variables involved in running the perfect portscan, every environment is different and as such will require tweaking to run efficiently.

Malware Analysis:

Practical Malware Analysis (Link)

The book is old, but the methodology is rock solid.

Programming / Scripting:

Python: Automate the Boring Stuff (Link)

Hope that helps.

u/d4ntr0n · 72 pointsr/cscareerquestions

Introduction To Algorithms is kind of the gold standard. It's heavily detailed, well written, and I'm pretty sure they put the word "Introduction" in there as a joke(it's 1292 pages).

u/TJSomething · 70 pointsr/CrappyDesign

I'd recommend figuring out who's responsible and them giving them a copy of Don't Make Me Think. It's a relatively short book, so they might actually read it, then they might actually get some good ideas.

u/Magical_Gravy · 61 pointsr/badcode

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.

u/TurkishSquirrel · 59 pointsr/learnprogramming

The C Programming Language (commonly known as K&R) remains the best resource for learning C.

u/indrora · 55 pointsr/CrappyDesign

the bookstores of American universities are independently owned/operated to the university, and in fact just license or are a reseller of materials from the university itself when it comes to branded gear.

They're known to overcharge for a lot of books. Consider that The C Programming Language costs $30 new for a copy. My university wants $50 for a used copy of an out of date printing that was based on a draft.

The professor of this class actively says "DO NOT BUY THE BOOK. I WILL PROVIDE YOU A PDF." Despite this, people still buy the book.

This semester, I bought a book for one of my classes on amazon because the bookstore was like "LOL IT'S OUT OF PRINT WE DON'T HAVE IT." This was inverse of the email (that was later claimed as "forged") from the instructor, forwarded from the bookstore, saying it was in stock. On top of that, they wanted $350 for a book that's $40 new.

u/srnull · 54 pointsr/programming

Sorry to see this getting downvoted. Read the about page to get an idea of why /u/r00nk made the page.

I have to agree with one of the other comments that it is way too terse at the moment. I remember when we learnt about e.g. d-latches in school and it was a lot more magical and hard to wrap your head around at first then the page gives credit for. That and, or, and xor gates can be built up from just nand gates (the only logic gate properly explained) is also glossed over. Either go over it, or don't show the interiors of the other logic gates.

The interactive stuff is really neat. Good work on that.

Edit: If anyone reading wants to learn this stuff in more detail, two good books are

u/username-proxy · 51 pointsr/learnprogramming
u/Little_darthy · 49 pointsr/programming

Edit: I didn't realize the link was just the first chapter. If you really liked it, I do suggest purchasing it. You can find it all online for free, but I do highly recommend just having this book. It's a fun read.

 

Here's an excerpt that I really love right from the beginning of the book.

>>All programmers are optimists. Perhaps this modern sorcery especially
attracts those who believe in happy endings and fairy godmothers.
Perhaps the hundreds of nitty frustrations drive away all
but those who habitually focus on the end goal. Perhaps it is
merely that computers are young, programmers are younger, and
the young are always optimists. But however the selection process
works, the result is indisputable: "This time it will surely run," or
"I just found the last bug."

Here's a link to a Physical copy [on Amazon] (https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959) if you want it.

 

edit: Bonus Dilbert Comic

u/berkes · 47 pointsr/webdev

Exactly this.

For quite some projects, I had to find a freelance frontender or webdesigner.
Here's how that goes:

  • I post an ad, classified or get names via referrers.
  • I wade through that to make a shortlist of 20+ candidates.
  • One by one I visit their sites, looking for a Resume or a Portfolio.
  • One by one, I have to wade through weird navigation, presentations, fucking horizontal scrolling, skipintros. I even had to open the source to find what fucking image represents a link to the portfolio. I've had to wait for some fancy JS caroussel to take me through the portfolio. I've had to watch videos, in order to see the resume.

    I'ts a great way to separate the rubbish developers from the good ones. If you manage to present your information on one page, with a few clicks to learn more about a certain project, in clean, simple HTML, preferable recenly updated to work on mobile (responsive): you're through. But if you cooked up your navigation while on LSD using Suprise.js or WhittyScroll.js you're out.

    Browsing 20+ sites from designers truly is a hell. So, nowadays, I simply ask them to email me the resumes.

    Because I too realise that a good webdeveloper or designer is hired most of the time. And as such, won't have time to redesign his or her site after every new change of technology. I can understand if your site looks like it was from 2008, if you've been hired and busy since 2008, it's actually a good sign.

    But really. Don't make me think. Ever.
u/Nezteb · 43 pointsr/compsci

Some book recommendations:

u/kevroy314 · 43 pointsr/compsci

I first heard about these when reading Godel Escher Bach back in later high school. That book was a long, difficult read, but man did it blow my brain wide open. Quines are definitely the thing that I remember most vividly (probably because it was the easiest to understand), but that book was full of awesome stuff like this.

You should totally check it out! You can get it super cheap at used book stores since it was such a successful book.

u/labmansteve · 42 pointsr/PowerShell

Honestly, I'd go with Windows Powershell Best Practices instead. PSIAMOL is nice, but this one focuses more heavily on ensuring you not only get the syntax, but the proper script structure, code re-usability, high performance, and just a ton of other stuff.

PSIAMOL Teaches you how to use PowerShell. WPBP teaches you how to be good at PowerShell.

Once that's done, it wouldn't hurt to check out Code Complete which had such an impact I ended up re-writing several of my larger scripts after reading it...

u/greentide008 · 42 pointsr/compsci
u/Shuank · 40 pointsr/argentina

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.

u/myfavoriteanimal · 40 pointsr/compsci

Code, by Charles Petzold

Here it is on Amazon.

u/xiongchiamiov · 39 pointsr/webdev

I've been in a somewhat similar situation. First off, tell your boss that the deadlines aren't happening. They're trying to get all three points of the project management triangle, and it's not going to work. They need to compromise on something. While they're figuring that out, let's get to work.

Step one, if you haven't done this already, is to check everything into version control. You can't do anything about the past, but you can fix the future.

Working Effectively with Legacy Code is a well-reviewed book. Maybe you'll find it more useful than I did - ask your boss to buy it for you. My summary of it is:

  1. Write tests for as much as you can without changing anything.
  2. Refactor a tad to open up more testing opportunities.
  3. Repeat.

    You need a working test environment. The one the customer calls production is ideal (for you), but if that's not going to work, you need something as close to it as possible. It is management's job to solve this problem for you so you can do your job. Tell them that you're working with the 4-hr feedback window, and the more time they take to fix that, the longer this is going to take.

    You mention that there's no documentation, and that you've read thousands of lines of code but still don't understand how it's pieced together. As you read the code, write the documentation. Be as extensive as you can. This is also a good time to write tests that verify the behavior you think is supposed to happen. And don't just read a file at a time, top to bottom - approach it always with a purpose, eg "how does this page get generated?". This will help you understand the flow, because you'll be tracing it repeatedly, so you'll start to see patterns in how it's all put together.

    May the Force be with you.
u/goldfire · 38 pointsr/javascript

The bottom line is that, whatever your rationale might be, this code is extremely difficult to read and understand for anyone who isn't you. I had to just skip over the entire tokenizer because I wasn't getting anything out of trying to read it, except for frustration. The algorithm portion isn't much better.

Good names are one of the best ways for an author to communicate how their code works to other programmers. They provide the foothold that the person reading the code needs so that they can begin understanding the algorithms. With what you've got here, the reader must already understand the algorithms before ever seeing the code, so that he can map the concepts he already has in his head onto the uninformative variable names.

I'll give you an example that I paraphrased from Code Complete, which, if you haven't heard of it, is one of the absolute classic works on the topic of how to construct good code. What do you think this code fragment is doing:

a = a - b;
c = d + sales_tax(d);
a = a + late_fee(e, a) + c;
a = a + interest(e, a);

Despite the good function names, it's still extremely difficult to figure out what this code is trying to accomplish; if I have to make a change in something that relates to this module, I don't know where to start. But, after we name the variables:

balance = balance - last_payment;
monthly_total = new_purchases + sales_tax(new_purchases);
balance = balance + late_fee(customer_number, balance) + monthly_total;
balance = balance + interest(customer_number, balance);

See how much easier it is now to see that this code is computing a customer's bill based on their outstanding balance and a set of new purchases from the current month?

Using good variable names allows anyone to just read your code and understand immediately what it is doing. Without good variable names, anyone reading your code has to already know what it is doing.

u/Grays42 · 38 pointsr/IAmA

This book is an amazing book I recommend for anyone who "knows how to write code" and has built a few things. It's a classic. Reading it cover to cover strengthened my coding skills considerably, and lessons I learned from it I apply to every new project I tackle.

[edit:] For example, the DRY principle: Don't Repeat Yourself. Basically, every operation and value in your code needs to be represented once. Two extremely similar functions? Do not copy and paste. Abstract the function slightly and find a way to make it do your two similar operations with the same basic function structure. This keeps your code clean and much easier to modify/maintain.

Need to do the same function in two different classes? Break the operation out into its own class or an abstract class (or other options depending on the language) and make both classes use it, because you'll probably find other similar crossovers that both classes will need. (These cases vary in practice, but you'll get a feel for it.) Hell, on a few occasions I realized after doing this that it was more practical to merge two or more classes into one giant abstract class and write smaller, specific children, and this helped tremendously.

Some situations might arise that this helps:

  • What if the functionality needs to change? You have to remember every place where this function is located, and if you miss one, you introduce errors.

  • What if a third or fourth use case appears with very similar functions? You have to copy and paste again, exacerbating the problem, or you simply use the existing framework you made and verify that it works.
u/jaimeandresb · 38 pointsr/compsci
u/fuzzyfuzz · 38 pointsr/sysadmin

This exists.

You have read our Bible, right? ;)

u/flebron · 37 pointsr/compsci

Introduction to Algorithms (CLRS). I bought this book the year before I started university. I've now moved into my own place, and the first book I brought was that one. There's no technical other book I've read that many pages of. It's really filled with information, and presented in a rigorous, formal way.

Definitely my best purchase, books or otherwise.

u/d4m45t4 · 35 pointsr/programming
u/testmypatience · 35 pointsr/startups

The books get outdated too fast.

This should help you though.

---

Validate Your Skill Level

Are you currently a web programmer? If no, please do not attempt to become one to code your own dynamic website as security is a huge issue and it will take you years to catch up. It is not a reasonable effort to put forth if you want to keep your sanity, not burn your spare time, etc. Not saying you can't learn it, just saying it takes a lot of work and time that most entrepreneurs don't have to use and in some cases waste.

You can learn how to do html and css within a few months but using a CMS system is much cleaner and easier and if you need something dynamic, you will probably need a developer.

You generally need to know at least php and mysql for dynamic websites unless you want to get into the confusing worlds of joomla and drupal. I hear decent things about Ruby on Rails though on par with php and mysql learning curve I think.

Want to Learn Web Programming Anyway?

Try CodeCademy for interactive programming learning.

No Coding Skills Start Here

Get / Use the following:

  • Hosting: Bluehost.com
  • Domain name: Buy through Bluehost and get a privacy option on it
  • Web Platform to one click install: WordPress a CMS platform
  • Find an appropriate responsive wordpress theme here: Themeforest.net
  • Install and configure these free plugins in order: Better WP Security, BackWPup, Akismet, Yoast, Broken Link Checker, FirmaSite Theme Enhancer, Growmap Anti Spambot Plugin, Date/Time Now Button, and Advanced Responsive Video Embedder
  • Buy other plugins you need here: CodeCanyon.net
  • Need an affiliate manager?: Use Linksert.net and it's free WordPress plugin.

    Need Something More Dynamic?

    You have a few options. This list goes from least expensive to most expensive. Just know that most things you want to do already have a plugin or theme designed for them for WordPress. There are however a lot of exceptions to that guideline and that is why you look at the following options.

  • Least Expensive end
  • Hire someone to develop a WordPress plugin to do that dynamic stuff (cheaper than second option)
  • Hire someone to build you a custom WordPress theme that has the functionality you need.
  • Hire someone to develop the site from the ground up.
  • Most expensive end

    The reason why WordPress is mentioned a lot is because it is a CMS aka Content Management System which allows you to manage a ton of the pages and posts and various other aspects of the website. If a developer really needs to, they can modify the core parts of WordPress. Rarely will you need someone to build you a brand new website and honestly you really do want a CMS or you are going to have a hard time.

    Some developers can be found here: Elance (freelancers), Matchist (freelancers), and Glowtouch (dev company vetted by Bluehost)

    Things to remember with website development

  • Try to use a responsive website themes and plugins so that it can fit any screen size including tablets and phones.
  • Get familiar with what they call "sticky footer" so that your footers don't end up halfway up the screen on low content pages. Example and info.
  • Get familiar with the concept of having a fixed header as it will promote a lot of use of your website. Example and info.
  • Design is important. You have ~2.6 seconds to capture their attention before they bounce. Read this book to learn about it: "Don't Make Me Think"
  • Best colors to use for design and other design tricks (the best you are going to find): Article and Video

    I am actually writing a series on this because this guide is way too small. You can sign up to be notified on this quick google form I threw up.
u/veryreasonable · 35 pointsr/RationalPsychonaut

As one of the people who commented on that thread, I feel the need to respond to this as rationally as humanly possible.

For starters, let's clear up the difference between fractal mathematics, fractal woo, and what Douglas Hofstadter might call fractal analogy.

  1. From the wiki - Fractal Mathematics would be the study of "natural phenomena or a mathematical sets that exhibits repeating patterns that display at every scale" as well as the study of self similarity and iterated functions. While it has grown complex and vast, the studies of fractals and their geometry started out as literally what you say it isn't: people asking questions about self-similarity in nature and asking how to describe it mathematically.

  2. Fractal Woo would be, as OP said:

    >“Everything big is just like everything small!” they exclaim, “the universe is self-similar!”

    ...and then using such logic to thereby justify whatever silly energy-Reiki-mystical-connectedness-telepathy-de-jour they want.

  3. Fractal Analogy (my term, but run with it) would be seeing patterns in the world which are, indeed, self similar, as tons of stuff in nature is. This includes plant and animal system, as well as consciousness and human experience. The reason I mention Douglas Hofstadter is that he is a PhD physicist who literally used fractal mathematics to predict some pretty nifty real world stuff 35 years before it was confirmed - but Mr. Hofstadter is also an incredibly enjoyable author who muses at length about cognitive science and AI research, often using the analogy of self-similar shapes to help describe what we understand of consciousness in a way that most layman readers can understand. Even if you are not a very capable mathematician, I highly recommend his Godel Escher Bach, which uses fractals and loads of other creative stuff to help conceptualize how the "mind" arises from the brain.

    As well, Chaos Theory - the study of how immensely complex patterns emerge from seemingly simple preconditions - is full of fractal mathematics. Given that the universe is absolutely packed with iterated functions and self-similarity almost everywhere we look, I think you can absolutely take the point of view that the universe is fractal in nature, especially when you are in a self-induced state where your brain makes a lot of connections you might normally overlook or not even bother to think about.

    My point is that discussing things in the universe as self-similar is useful to mathematicians and non-mathematicians alike; using the word "fractal" to describe natural systems that exhibit those familiar patterns might not be perfectly correct, but it's not itself offensive or an affront to reasonable discourse. I manage a business; so what's your problem if I visualize the structure of my company as a fern leaf with departments and employees as branches off the main stem? What would be the issues of discussing how incredible human cellular morphology really is with my biologist roommate, and citing some cool research someone decided to do about fractal geometry in the way our bodies build themselves?

    EDIT: OP's edit makes it more clear his statements were more about irrational folk seeing the universe as a single continuous fractal (that would be the "fractal woo"), and that he is not denying the existence of fractal-like patterns in nature, or that using fractal models can be useful in understanding phenomena. Sorry for any confusion and thanks for the discussion!

    EDIT2: /u/ombortron commented pretty well in regards to the utility of the concept of fractals in scientific discourse and otherwise:

    >The universe itself doesn't have to be a fractal for fractals to be important.

    >Fractals are quite common in our reality, and as a result, that means they are an important facet of reality, and as such they are a legitimate and common topic of discussion amongst people, and this is particularly true of people who do psychedelics.

    >Does this mean the universe is 100% fractal in nature? No.

u/underwatr_cheestrain · 34 pointsr/javascript

Get your man pants on and pick up a copy of CLRS.

u/revertTS · 33 pointsr/compsci
u/Tiberius1900 · 33 pointsr/learnprogramming

To get a feel for low-level computing you should learn C. All modern operating systems and low level utilities are written in C (or C++, which is C with objects). It is as close to the metal as you can get while still being useful. Maybe you could fiddle around with some assembly afterwards.

Now, as for understanding how an operating system form top to bottom works, Windows is a pretty shit place to start for the following reasons:

  • Proprietary nature means little documentation about how the OS actually works internally.
  • Single desktop environment and lack of naked shells makes it hard to understand how and why some things work.
  • Limited capabilities for programming without an IDE, which is what you should be doing if you want to learn C (note that I said learn C. Particularly in the context of understanding, say, how data streams and the like work, programming without an IDE is infinitely better).
  • etc.

    Instead, you should learn Linux, and learn how Linux works. Installing it in a VM is fine. If you're looking to learn, I suggest you start with Debian, and, after you get comfortable with the command line, move to Arch. Arch is great for learning, if not much else, because it makes you do most things manually, and has a pretty extensive wiki for everything you may need to know.

    Resources:

    A Linux tutorial for beginners: https://linuxjourney.com

    A pretty decent online C tutorial (note, you should compile the programs on your own system, instead of doing their online exercises): http://www.learn-c.org

    K&R2 (the "proper" way to learn C): https://www.amazon.com/dp/0131103628/ref=cm_sw_r_cp_awdb_t1_FSwNAbFDJ3FKK

    Computer Systems A Programmer's Perspective, a book that might just be what you're looking for: https://www.amazon.com/Computer-Systems-Programmers-Perspective-3rd/dp/013409266X
u/krabby_patty · 33 pointsr/java

Surprised Effective Java didn't show up

Edit: Did a little digging and I see a Third Edition seems to be under way for Java 7/8

  1. https://twitter.com/joshbloch/status/811983663525085184

  2. https://twitter.com/joshbloch/status/796939556658573312
u/geek_on_two_wheels · 33 pointsr/csharp
u/jhartikainen · 32 pointsr/cscareerquestions

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.

u/wall_time · 32 pointsr/programming

Charles Petzold also wrote Code: The Hidden Language of Computer Hardware and Software. It's a great book. I'm sure most of the people browsing this subreddit will already understand most of what is in the book (or have read it already) but fantastic read nonetheless.

u/jesseguarascia · 31 pointsr/gamedev

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

u/LunarKingdom · 31 pointsr/gamedev

If you write your code in a meaningful, clean and understandable way itself, comments are almost useless and, in many cases, a source of misunderstanding and mistakes (especially working with other people). If you add too many comments, you need to update them with every single change you make to the code to keep them useful, which is an extra maintenance cost.

Suggestions:

  • Name your variables and methods properly, sometimes people name things with cryptic and short names hard to understand.
  • Use refactoring techniques, design patterns (when appropriate) and SOLID principles to make code clean, familiar, easy to maintain and extend.

    After 10 years of experience as a programmer working on different teams, my opinion is the fewer comments, the better.

    I recommend you this book, a classic: https://www.amazon.es/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
u/FunkyCannaHigh · 30 pointsr/MrRobot

Excellent questions! If you are a CS grad you are ahead of the game. However, it all depends on what you want to do. I suggested learning programming/CS principles for two reasons:

  1. The more you understand how computers, code, compliers, software, stacks, memory randomization, CPU protection rings, and the such work the better you are at hacking. You can find novel ways to get into systems and exploit them, etc.

  2. You can write basic tools on the fly. It is amazing the tools you can create with a few lines of code when you have access to nothing but a GCC compiler in a *nix environment.

    If you want to find zero day exploits, yes learn how low level languages work. It would be very helpful in that case.

    Otherwise, Learn python (or whatever is popular at the time) to write your own exploit tools....or to modify existing ones.


    If you want to be apart of a red team learning lower level languages could make you a better exploiter. However, IMO, I would start with just learning the basics of hacking.


    These two books are old but they are absolute standards for anyone starting off:

    https://www.amazon.com/dp/1593271441/ref=cm_sw_r_cp_awdb_t1_GYIACb1Z2YXFA

    And:

    https://www.amazon.com/dp/1593275641/ref=cm_sw_r_cp_awdb_t1_zZIACbMH0WTMP


    Also, learn as much as you can on how windows/Linux/virtual machines (and containers) work. The more you know about how an OS works the easier it is to exploit.

    Learn to exploit, there are a ton of free sites to help you learn:

    http://overthewire.org/wargames/


    https://www.cybrary.it



    www.vulnhub.com


    http://google-gruyere.appspot.com



    Learn CTF challenges:

    https://ctflearn.com


    When you are able to hack take part in real challenges:


    https://ctf365.com


    Then start your career with a RESPECTED CERT, OSCP:


    https://www.offensive-security.com/information-security-certifications/oscp-offensive-security-certified-professional/

    The OSCP is no joke and it is a timed, 24 hour cert test. Yes, you read that right, 24 hours.

    Unless you want a government gig stay away from C|EH, it is a joke cert in the community. Again, unless you need to work for a gov agency



    Finally, and I cannot stress this enough.....LEARN CLOUD COMPUTING!!! It is here to stay and on-prem systems are dying a slow death. It will change how you exploit systems and how software is engineered/deployed.

u/Leave-A-Note · 29 pointsr/web_design

It's not a long book, but it is all about usability. It's called "Don't Make Me Think". It's informative and concise.

That Amazon Link: https://www.amazon.com/dp/0321965515/ref=cm_sw_r_cp_api_5Ohuzb82F6BEF

u/Lord_NShYH · 29 pointsr/sysadmin
u/hrastignac · 28 pointsr/learnprogramming

Clean Code is widely considered (at least in my circles) as a "must read" position for a pragmatic coder.

u/hooj · 28 pointsr/explainlikeimfive

The whole subject is a bit too complicated and a bit too deep for a short ELI5, but I'll give a stab at the gist of it.

The reason why computers work (at least in the vein of your question) is very similar to the reason why we have language -- written, spoken, etc.

What you're reading right at this very moment is a complex system (language) simplified to symbols on the screen. The very fact that you can read these words and attain meaning from them means that each sentence, each word, and each letter represent a sort of code that you can understand.

If we take an apple for example, there are many other ways to say that in different languages. Manzana. Pomme. Apfel. And so on. Codes -- some symbol maps to some concept.

In the context of computers, well, they can only "understand" binary. Ones and zeros. On and off. Well, that's okay, because we can map those ones and zeros to codes that we (humans) care about. Like 101010111 could represent "apple" if we wanted it to.

So we build these physical circuits that either have power or don't (on and off) and we can abstract that to 1's (power flowing through that circuit) and 0's (no power flowing through it). This way, we can build physical chips that give us basic building blocks (basic instructions it can do) that we can leverage in order to ultimately make programs, display stuff, play sounds, etc. And the way we communicate that to the computer is via the language it can understand, binary.

In other words, in a basic sense, we can pass the processor binary, and it should be able to interpret that as a command. The length of the binary, and what it should contain can vary from chip to chip. But lets say our basic chip can do basic math. We might pass it a binary number: 0001001000110100 but it might be able to slice it up as 0001 | 0010 | 0011 | 0100 -- so the first four, 0001, might map to an "add" command. The next four, 0010, might map to a memory location that holds a number. The third group of four might be the number to add it to. The last group might be where to put it. Using variables, it might look like:

c = a + b. Where "c" is 0100, "a" is 0010, "b" is 0011, and the "+" (addition operator) is 0001.

From there, those basic instructions, we can layer abstractions. If I tell you to take out the trash, that's a pretty basic statement. If I were to detail all the steps needed to do that, it would get a lot longer -- take the lid off the can, pull the bag up, tie the bag, go to the big garbage can, open the lid, put the trash in. Right? Well, if I tell you to take out the trash, it rolls up all those sub actions needed to do the task into one simple command.

In programming, it's not all that different. We layer abstractions to a point where we can call immense functionality with relatively little code. Some of that code might control the video signal being sent to the screen. Some of that code might control the logic behind an app or a game. All of the code though, is getting turned into 1's and 0's and processed by your cpu in order to make the computer do what is asked.

If you want to learn more, I highly recommend Code by Charles Petzold for a much more in depth but still layman friendly explanation of all this.

u/ryanpeden · 28 pointsr/webdev

I've been here a few times in my decade-long career.

To start, this isn't something that only happens to junior developers. Trying to approach a large existing code base can be a real challenge, even when you have lots of experience.

You're not going to understand the whole application in a day. Probably not even in a week, and probably not even in a month. On some large code bases, I've regularly run into new code *years* after I first started working on the application.

What I've found helpful is to pick a small part of the application; preferably one that's related to a feature you're trying to add or a bug you're trying to fix. Find what looks like the entry point of that small part of the application. In a web app, it could be a method in a controller class. Or it could be a method in a service class somewhere.

Once you've found that entry point, read through the code one line at a time, and try to make sure you understand what's happening at each point. If the method you're in calls another method/function, jump to that and go through it one line at a time. On code that's particularly complex, I'll grab some sheets of lined paper, and devote one sheet to each method I go through.

As I go through each method, I'll write out the whole thing by hand as pseudocode. In order to do this, I have to understand what the code is doing. Some people might find it more effective to do this in a text editor. I find that there's something about the process of physically writing it out on paper that really helps cement my understanding.

Now, the whole writing out part isn't worth it if you just need to go in and do a quick bug fix. But if you've been handed responsibility for a chunk of code and you'll need to understand it deeply, I've found it to be a useful approach. I think it can still be helpful even if you're not solely responsible for a piece of code, but will have to work on it heavily.

Start by deeply understanding one important part of the code. Then move on to understanding another important part. Soon, you'll start to see patterns and understand how these important bits of code fit together.

If you're not yet sure what the important parts of the code for you to understand are, then a good way to find out would be to look at the repository's commit history to see which files have the most commits over time. The places that change the most often are likely the ones *you* are going to have to change, so they are a good place to begin. You can find instructions on how to do this here:

https://stackoverflow.com/questions/5669621/git-find-out-which-files-have-had-the-most-commits

That assuming your code is in a Git repository. If you team uses Mercurial, you can look up instructions on how to do the same thing. If your team uses Subversion or heck, even CVS, you can probably accomplish the same thing. If your team doesn't use source control at all, then start spiking your morning coffee with rum or Kahlua because that will make your job significantly less painful.

For a look at using Git commit history to find the most important code - and the parts with the most technical debt - I enjoyed a book called Software Design X-Rays.

I've found the book Working Effectively with Legacy Code to be quite helpful in showing me different ways to approach an existing code base. Even if you don't apply all of the techniques the book suggests, I think it's still useful for finding out ways to find 'seams' in the code that you can use as points of attack when refactoring, adding features, or even just choosing a place to start learning a new bit of code.

If your employer will let you expense the cost of eBooks, you might find these interesting. If you can get access to Safari Books Online, both these books are available on there, along with a metric ton of great software development books. You might not need to pay for it - in my city, everyone with a public library account can access Safari for free. Maybe it's similar where you are?

Also, if you have a particularly frustrating day, feel free to come on Reddit and send me a DM. I might just have some useful advice. And if I don't happen to have useful advice on a particularly topic, I'll at least be able to come up with an on-topic smartass remark that will help you laugh and feel better about the code that frustrated you.

u/JonKalb · 28 pointsr/cpp

Modern C++ (C++11 or later) books are not nearly as plentiful as those for Classic C++, but there are a few notables.

Bjarne's college text may be what you are looking for:

Programming: Principles and Practice Using C++ https://www.amazon.com/Programming-Principles-Practice-Using-2nd/dp/0321992784/ref=pd_sim_14_2/144-7765085-0122037

It is aimed at engineers, which makes it less general, but might be good for you.

Of course his general intro is also updated to C++11.

The C++ Programming Language https://www.amazon.com/C-Programming-Language-4th/dp/0321563840/ref=pd_sim_14_2/144-7765085-0122037

This is aimed at experienced systems programmers, so it may be a bit heavy for students, which makes the Primer (that you mentioned attractive).

C++ Primer https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113/ref=pd_bxgy_14_img_2/144-7765085-0122037

Be certain to get the 5th edition.

Of Scott's books only the latest is Modern.

Effective Modern C++ https://www.amazon.com/Effective-Modern-Specific-Ways-Improve/dp/1491903996/ref=pd_sim_14_2/144-7765085-0122037?_encoding=UTF8

This is less an introduction for students than for Journeymen (Journeypeople?) programmers.

For just plain good programming style consider Ivan's book.

Functional Programming in C++ https://www.amazon.com/gp/product/1617293814

Don't be put off by "Functional." This style of programming will make your students excellent programmers.

There are some modern books of high quality that are niche.

The ultimate guide to templates:
C++ Templates https://www.amazon.com/C-Templates-Complete-Guide-2nd/dp/0321714121/ref=pd_sim_14_1/144-7765085-0122037

The ultimate guide to concurrency:
C++ Concurrency in Action https://www.amazon.com/C-Concurrency-Action-Anthony-Williams/dp/1617294691/ref=pd_sim_14_1/144-7765085-0122037

Some library options:

Despite its name, this is mostly reference. A very good reference.
The C++ Standard Library: A Tutorial and Reference (2nd Edition) https://www.amazon.com/Standard-Library-Tutorial-Reference-2nd/dp/0321623215/ref=pd_sim_14_2/144-7765085-0122037

Arthur's book covers C++17, which makes it one of the most modern on this list:
Mastering the C++17 STL: Make full use of the standard library components in C++17 https://www.amazon.com/Mastering-17-STL-standard-components-ebook/dp/B076CQ1RFF/ref=sr_1_fkmrnull_1

To what extent are you teaching C++ and to what extent are you teaching programing?

Good luck and have fun!

u/stevewedig · 28 pointsr/programming

Probably start by reading Michael Feather's book about this: Working effectively with legacy code.

http://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052/

u/meliko · 27 pointsr/AskReddit

Depends on what you want to do — UX is a pretty broad field. I'm a user interface designer with a UX background, which means I've designed sites, web apps and mobile apps, but there's plenty of UX positions that don't require any sort of visual design or front-end development experience.

For example, there are labs that conduct user research and interviews, run focus groups, or do user testing. Hell, you could even apply to be a user tester at a site like usertesting.com. Not sure how much money you can make from that, but it's something.

Also, there are UX positions that go from beginning research and discovery for projects up through the wireframing, which doesn't require any visual design experience. You'll usually hand off your UX work to a designer or a developer to implement.

Some good books to read about UX are:

u/cholland89 · 27 pointsr/compsci

I just finished reading Code: The Hidden Language of Computer Hardware and Software and will state unequivocally that this book is the most satisfying read I've experienced. It starts with flashlights blinking through windows, moves to Morse code, introduces electrical relays and demonstrates how they can be connected to form logic gates, then uses those gates to construct an ALU/counter/RAM and multiplexors. It goes on to describe the development of an assembly language and the utilization of input and output devices.

This book can be described as knowledge hose flooding the gaps in my understanding of computer hardware/software at an extremely enjoyable pace. It may help satisfy your interest in the concepts and technology that led to modern computers. Check out the reviews for more info.

If you haven't already studied logic gates in depth in your formal education, I would suggest using a logic simulator to actually build the combinational logic structures. I now feel very comfortable with logic gates and have a strong understanding of their application in computing from my time spent building the described logic.

I went through the book very slowly, rereading chapters and sections until I felt confident that I understood the content. I can not recommend this book enough.

After reading CODE, I have been working through The Elements of Computing Systems: Building a Modern Computer from First Principles. If you are looking to gain a better understanding of the functions of hardware components, this is the book to read. This book's companion site http://www.nand2tetris.org has the first chapters free along with the entire open source software suite that is used in the book's projects. You will build, in the hardware design language starting with Nand gates, each logic gate and every part of a computing system up to a modern high level language with which you can program custom software of your own design to compile in a compiler you designed into an assembly language you specified which is turned into binary that runs in a processor you built from Nand gates and flip flops. This book was very challenging before reading CODE, now I feel like I'm simply applying everything I learned in code with even more detail. For somebody that hasn't attended college for computing yet, this has been a life changing experience.

http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319


http://www.amazon.com/The-Elements-Computing-Systems-Principles/dp/0262640686

u/stevenxdavis · 27 pointsr/compsci

I just started reading CODE by Charles Petzold and I've really enjoyed it so far. It's an accessible take on the basics of computer science that doesn't just focus on computers themselves.

u/JBlitzen · 27 pointsr/learnprogramming
u/DarkAnt · 26 pointsr/compsci

I don't know how to tell you how code well, because I don't know how to do it myself. I look at John Carmack, Bjarne Stroustrup, Guido van Rossum, Herb Sutter and co. and I realize how poorly I measure. That said, I do know of some things that will certainly help you. I believe to get good at something takes time and dedication. The following is in the order that I thought of it. I'm not sure how you should attempt to learn this material. Hopefully someone else can help you out with that.


Learning how to recognize potential solutions to classes of problems and of course having the basic tools to design a solution.

u/bpikmin · 26 pointsr/programming

I highly recommend the book Code. I read it in middle school and it was absolutely fascinating. Pretty short too.

u/TieDyeJoe · 26 pointsr/java

Get Effective Java by Josh Bloch.

u/browngray · 26 pointsr/sysadmin

Lots of books here.

If it has to be absolutely one book, The Practice of System and Network Administration is one on how to be a well rounded sysadmin.

u/Vitate · 26 pointsr/cscareerquestions

Much of this stuff is learnable outside of work, too, at least at a superficially-passable level. Trust me.

Pick up a few seminal books and read them with vigor. That's all you need to do.

Here are some books I can personally recommend from my library:

Software Design

u/Lericsui · 26 pointsr/learnprogramming

"Introduction to Algorithms"by Cormen et.al. Is for me the most important one.

The "Dragon" book is maybe antoher one I would recommend, although it is a little bit more practical (it's about language and compiler design basically). It will also force you to do some coding, which is good.


Concrete Mathematics by Knuth and Graham (you should know these names) is good for mathematical basics.


Modern Operating Systems by Tennenbaum is a little dated, but I guess anyone should still read it.


SICP(although married to a language) teaches very very good fundamentals.


Be aware that the stuff in the books above is independent of the language you choose (or the book chooses) to outline the material.

u/cronin1024 · 25 pointsr/programming

Thank you all for your responses! I have compiled a list of books mentioned by at least three different people below. Since some books have abbreviations (SICP) or colloquial names (Dragon Book), not to mention the occasional omission of a starting "a" or "the" this was done by hand and as a result it may contain errors.

edit: This list is now books mentioned by at least three people (was two) and contains posts up to icepack's.

edit: Updated with links to Amazon.com. These are not affiliate - Amazon was picked because they provide the most uniform way to compare books.

edit: Updated up to redline6561


u/feketegy · 25 pointsr/PHP

Every quality software should have tests. So...

Read the unit tests / features tests first. Those will show you how a specific piece of the code works.

Also:

  1. Play with composer packages.
  2. Learn about PHP SPL
  3. Learn about design patterns and beyond
  4. Learn TDD, setup PHPUnit, Behat, Mink, PHPSpec
  5. Read PHP The Right Way
  6. Learn about clean code, EBI, DCI and how to put MVC on a shorter leash here: http://ikke.info/clean_code.html and here http://ikke.info/todo.txt and check out the #cleancode IRC channel on freenode
  7. Read a couple of books like: PHP Objects, Patterns and Practice or Code Complete or Clean Code or The Pragmatic Programmer or The Mythical Man-Month
  8. Start an open-source project or contribute to one


    There are a lot to learn and if you really like programming you will never stop learning.

u/leodavinci · 25 pointsr/sysadmin

I highly recommend The Practice of System and Network Administration. Goes over a whole bunch of real world tips of what you will need to be successful and keep you sane in the process. Goes over ticketing systems, time management, documentation, patching, imaging, and various other processes that are vital for any Sys Admin.

http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668/ref=pd_bxgy_b_text_b

u/CapableCounteroffer · 25 pointsr/learnprogramming

You can get a degree or you can teach yourself

The above resource is pretty good in outlining the major topics that all CS programs cover, but I would change some of their textbook and class recommendations.

I would replace the programming book/course with CS for all

Algorithms I would recommend sedgewick which is also available as a website or clrs for a more in depth review.

Those two topics will give you a very solid background. For what you want to do computer architecture, networking, operating systems, math, languages and compilers, and distributed systems aren't as important. If you wanted to expand your abilities as a programmer then you should explore those topics.

As for databases, for your purposes you may not need to learn so much how databases work as opposed to how to query databases. For this you need to learn SQL.

This should give you all the background you need in CS, now its time to start building applications. You'll probably hit roadblocks and need to research how to accomplish certain tasks, but with the above background that should be very doable.

u/MemeSearcher · 24 pointsr/learnprogramming

A good book for you would be clean code. I'm only part way into it, but it's a really good resource for learning better code practices. You won't find much commenting in there, however, as their philosophy is that you shouldn't need comments if you do it right. It might be a good place to start if you're willing to look for good commenting practices elsewhere

u/sempuki · 24 pointsr/cpp

It depends on whether you're a beginner to C++, a beginner to programming or both. It also depends on whether you prefer a tutorial style -- where you read closely and walk step by step with the author, or a reference -- where you skim, go at your own pace, and follow up when you need more details.

Accelerated C++ is more of a short introduction that hits all the broad strokes. It's good for someone who's already very adept but just needs to get into the mindset of C++.

Principles and practice is a tutorial style book suitable for an introductory course, and isn't a bad choice. The C++ Programming Language is more of a reference style and would be good for people who really prefer that direction.

I've read parts of How to Program Java and definitely was not impressed -- not sure how 9th ed of C++ stacks up.

I'm assuming a beginner is new to programming, but by virtue of choosing C++ enjoys the technical details that allows you to make the most of the language. My recommendation for this kind of user by far and away is C++ Primer by Lippmann, Lajoie, Moo (not to be confused with Primer Plus). This book (3rd ed) was what made me fall in love with the language in university.

It's written by people who were deeply involved in the standards, wrote actual compilers, and know how to present the material in ways that are relevant to the student. The 3rd ed also had sections that went further and explain the underlying compiler mechanism for a given feature which I found so insightful. They somehow managed to marry a high-level tutorial style narrative with important low level technical details that very much mirrors the style of the language itself. The 3rd ed also explicitly called out C++ as a mutli-paradigm language where functional style was possible (which was my first introduction to the concept of functional programming).

I'm not sure how much of that book survives in the 5th ed, but either way I recommend you read the book yourself and see if it's something that resonates for you. I'm looking through a copy of 5th ed right now, and it looks like much of that spirit is still alive. The down side is it appear it's still on strictly C++11, which given the size of the language and intended audience, I don't think is a fatal weakness.

If you want a complement to C++ Primer, Stroustrop's reference is the most complete, but to be honest I prefer C++ Reference for a working programmer.

I highly recommend ditching IDEs entirely for learners precisely because they make it harder to detect and learn from your mistakes. Get a copy of a linux distro, or install XCode command line tools, and invoke GCC/Clang directly. By the time you need to move into larger projects you'll have developed your own opinions on build systems/IDEs.

u/bcguitar33 · 24 pointsr/compsci

Introduction to Algorithms is an absolute classic. It covers the vast majority of the algorithms that a good programmer "should" know (and goes over much of the math in the appendix in the back). Every school I've worked with has at least 1 course using this text, and typically each company doing anything interesting has at least 1 copy floating around somewhere.

I have a bunch more books that I could personally recommend if you have a specific thing you're trying to learn, but in terms of books that are 100% canon, that's the only one that comes to mind for me.

u/technogeeky · 24 pointsr/AskReddit
u/devilbunny · 23 pointsr/explainlikeimfive

That's a pretty interesting course. I've read the book and done exercises up until you actually have to start building the CPU.

However, I would strongly recommend reading Charles Petzold's CODE first. It's a little less technical, but explains the general concepts much better than nand2tetris.

u/__LikesPi · 23 pointsr/learnprogramming

Algorithms are language agnostic but certain books are not. I recommend Introduction to Algorithms which is language agnostic and accompanied by lectures here. But there is also Algorithms by Robert Sedgewick which is in Java and accompanies these lectures and The Algorithm Design Manual which is language agnostic.

u/wigflip · 23 pointsr/Bitcoin

Well firstly, language is a big choice right now. If you're looking to make a financially fulfilling career in a young company or on your own, I'd recommend learning javascript to later use node.js, and learning ruby. Personally, I'm a node.js developer, so I would recommend moving toward the JS world and using really cool things like socket.io and mongoDB. Ruby is a fantastic language overall. It's a bit slow, but it does a great job regardless, and tons of really cool startups use it. At the moment, I would say that these are the two most profitable paths to take in web development.

http://codeacademy.com is a fantastic place to start. It does a great job at teaching the fundamentals of programming. If I recall correctly, the javascript courses take you from the absolute basics to building some kind of useful application, such as a calculator or todo list.

Once you've made your way through the tutorials at codeacademy, move on to http://codeschool.com. Their tutorials are a bit more advanced, and leave you with a real application and real knowledge on how to take an idea and turn it into a real product. For node magic after you've moved through Codeschool, check out http://nodeschool.io/

Here are a few books I would recommend

JAVASCRIPT

u/in0pinatus · 23 pointsr/programming

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 new message 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.

u/smark22 · 22 pointsr/compsci
u/teknobo · 22 pointsr/programming

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.

u/abstractifier · 22 pointsr/learnprogramming

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.

u/brownmatt · 22 pointsr/programming

I think the two suggestions you'll see the most will be:

Code Complete

Pragmatic Programmer

u/darawk · 22 pointsr/compsci

Godel Escher and Bach is precisely what you're looking for.

u/the_wood47 · 22 pointsr/graphic_design

I’m a print and basic web designer that’s been making an overhaul towards UI/UX the past few months so maybe I can offer some help. I’m actually working on a mobile app’s case study as we speak! You may have already noticed that UI/UX tends to get many different definitions depending on who you ask. With this said the path I took was focused on research methods (competitor research, demographic research, user testing, etc), UX deliverables (personas, user flows, wireframes, etc), prototyping, high-fidelity design and front-end coding (I’ll touch on that a little more in a bit).

 

When it comes to UX research I found the following resources immensely helpful:


Books (Reading? Yes, reading. Trust me these are worth checking out…pretty short too)

  • Don't Make Me Think

  • UX Team of One

  • Lean UX


    Podcasts (Listen on your commute, while you’re folding laundry, whenever)


  • User Defenders Podcast


    Websites (It’s also a good idea to Google some successful UX designer’s portfolios)


  • UX Mag

  • Reddit User Experience

  • “How I Became a Unicorn” <— Seriously check this out

     

    Basically what UX teaches you is that all design decisions need to be backed by an informed reason. That reason is found by doing proper research and testing.

     

    Now for UI design. There’s always Bechance and Dribble for inspiration, but a lot of the pieces you find on there lack context and are merely pretty to look at. So don’t get too obsessed. For software, personally, I’m a Photoshop to Sketch convert. It’s $100 but MAN is it worth it. There’s a number of things that make Sketch attractive (vector based, easy exporting, etc) but I guess the simplest way I can put it is that Sketch just feels…lighter than Photoshop. But it’s really personal preference, if you’re a master at using Photoshop for web design then don’t feel like you have to get Sketch. With that said I HIGHLY recommend investing in Meng To’s Design+Code. While it mainly focuses on iOS design, there is a lot of information that goes across the board for UI design, and it will give you an organized learning method (plus a discount on Sketch).

     

    It’s also a good idea to familiarize yourself with Material Design. Google’s presentation of the topic gets a little too in-depth at times so you may just want to Google search for other explanations of Material Design (that’s a bit ironic huh?).

     

    Okay so now you know how to design a basic UI right? Well what if you want to make your designs interactive? There’s quite a bit to benefit from actually seeing your designs work (or not work). Over the past couple years there’s been a gigantic influx of prototyping programs. They all have their pros and cons. Personally I use Pixate but at times it can be a little restricting. My iOS developer friend recommends Origami, it has a pretty steep learning curve but I think I may switch to that at some point.

     

    The key to becoming effective at UI design is the same with any other form of design: practice, practice, practice.

     

    Okay, now on to coding:

     

    Depending on your goals you may have to alter your studies a bit. For example, knowing your way around HTML/CSS and jQuery will give you more control of the design process, improve your relationship with developers on your team and make you EXTREMELY marketable. However, in many cases, only a basic knowledge of those languages I mentioned is required (jQuery being more of a bonus). As a designer you may not even touch the coding side of things at all, it really just depends on the team you’re working with. With that said I HIGHLY suggest taking a dive into front-end coding eventually, you’ll hate yourself for not learning it earlier. Ditch dreamweaver too, pickup SublimeText. Team Treehouse and CodeAcademy are fan-fucking-tastic. Learned a lot from their education programs.

     

    Whew, if that seems like a lot it’s because it is. Hopefully I broke it down into digestible chunks though. Remember, design is a never-ending learning experience. Don’t stop learning.
u/md81544 · 21 pointsr/javascript
u/MyrddinE · 21 pointsr/programming

Gödel, Escher, Bach: An Eternal Golden Braid

This book is not exactly a programming book... maybe... kinda. It teaches no practical programming language. It explains no useful design patterns. It does not deal with any practical computer applications. And yet had I never would have really gotten into programming had I not read it long ago. Written in the late 70's, it's still relevant today.

u/reddilada · 21 pointsr/learnprogramming
u/Ispamm · 21 pointsr/androiddev

Don't give up just yet, keep looking.
Do you have a portfolio? if not try to work on a project of your own so you can have something to show.
And if you are considering improving your java skills try work with libraries like:

u/zakimirza88 · 21 pointsr/java

Head First Java is what you want.

u/scramjam · 20 pointsr/learnprogramming

There are no good online C++ tutorials. If you want to learn C++ you'll need a good book, C++ Primer 5th Ed. is great for beginners (it's recommended in the wiki!).

u/diablo1128 · 20 pointsr/cscareerquestions

Clean code by Robert Martin AKA Uncle Bob.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882


He also has a website with videos that go over topics from the book and more:
https://cleancoders.com/videos

u/shivasprogeny · 20 pointsr/learnprogramming

How deep do you want to go? Code: The Hidden Language of Computer Hardware and Software goes all the way from binary to computer code.

If you don't really care about the hardware, you might start dabbling in assembly on a Raspberry PI.

u/DucBlangis · 20 pointsr/netsecstudents

Here is a "curriculum" of sorts I would suggest, as it's fairly close to how I learned:

  1. Programming. Definitely learn "C" first as all of the Exploitation and Assembly courses below assume you know C: The bible is pretty much Dennis Richie and Kernighan's "The C Programming Language", and here is the .pdf (this book is from 1988, I don't think anyone would mind). I actually prefer Kochan's book "Programming in C" which is very beginner freindly and was written in 2004 rather than 1988 making the language a little more "up to date" and accessible. There are plenty of "C Programming" tutorials on YouTube that you can use in conjunction with either of the aforementioned books as well. After learning C than you can try out some other languages. I personally suggest Python as it is very beginner friendly and is well documented. Ruby isn't a bad choice either.

  2. Architecture and Computer basics:
    Generally you'll probably want to look into IA-32 and the best starting point is the Intel Architecture manual itself, the .pdf can be found here (pdf link).
    Because of the depth of that .pdf I would suggest using it mainly as a reference guide while studying "Computer Systems: A Programmers Perspective" and "Secrets of Reverse Engineering".

  3. Operating Systems: Choose which you want to dig into: Linux or Windows, and put the effort into one of them, you can come back to the other later. I would probably suggest Linux unless you are planning on specializing in Malware Analysis, in which case I would suggest Windows. Linux: No Starch's "How Linux Works" is a great beginner resource as is their "Linux Command Line" book. I would also check out "Understanding the Linux Kernel" (that's a .pdf link). For Windows you can follow the Windows Programming wiki here or you can buy the book "Windows System Programming". The Windows Internals books are generally highly regarded, I didn't learn from them I use them more as a reference so I an't really speak to how well they would teach a "beginner".

  4. Assembly: You can't do much better than OpenSecurityTraining's "Introductory Intel x86: Architecture, Assembly, Applications, & Alliteration" class lectures from Xeno Kovah, found here. The book "Secrets of Reverse Engineering" has a very beginner friendly introduction to Assembly as does "Hacking: The Art of Exploitation".

  5. Exploitation: OpenSecurityTraining also has a great video series for Introduction to Exploits. "Hacking: The Art of Exploitation" is a really, really good book that is completely self-contained and will walk you through the basics of assembly. The author does introduce you to C and some basic principles of Linux but I would definitely suggest learning the basics of C and Linux command line first as his teaching style is pretty "hard and fast".

  6. Specialized fields such as Cryptology and Malware Analysis.


    Of course if you just want to do "pentesting/vuln assessment" in which you rely more on toolsets (for example, Nmap>Nessus>Metasploit) structured around a methodology/framework than you may want to look into one of the PACKT books on Kali or backtrack, get familiar with the tools you will use such as Nmap and Wireshark, and learn basic Networking (a simple CompTIA Networking+ book will be a good enough start). I personally did not go this route nor would I recommend it as it generally shys away from the foundations and seems to me to be settling for becoming comfortable with tools that abstract you from the real "meat" of exploitation and all the things that make NetSec great, fun and challenging in the first place. But everyone is different and it's really more of a personal choice. (By the way, I'm not suggesting this is "lame" or anything, it was just not for me.)

    *edited a name out





u/MrBushido2318 · 20 pointsr/gamedev

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!

u/Jank1 · 20 pointsr/networking

I would also like to take the time to plug a few resources, if I may, that have greatly assisted me throughout my career.

  1. Of course, Cisco Press. Wendell Odom especially.
  2. Non-Cisco Press, Todd Lamlle's CCNA book is great!
  3. CBT Nuggets!! Jeremy Cioara and Keith Barker.
  4. Tech Exams Forums!! For answers to your questions regarding certification, study material, etc, from a variety of vendor certs. Or, to just read motivating success stories!!
  5. Internetworking Experts (INE!) That link should direct you to their free CCNA video course. If that doesn't work for you, simply register an account with them and search for the CCNA video course.
  6. Thomas Limoncelli's The Practice of Systems and Network Administration
  7. Gary A Donahue's Network Warrior
  8. Jeff Doyle's CCIE Professional Development Routing TCP/IP Vol. 1 or 2
  9. Douglas E. Comer's Internetworking with TCP/IP
  10. GNS3!! Free Cisco Router and ASA Emulation!! Just make sure you have access to Cisco IOS software!
  11. Andrew S. Tanenbaum's Computer Networks.
  12. Jeremy Stretch and PacketLife!! Also, Jeremy's network Cheat Sheets!
  13. Firewall.cx!!
  14. Cisco's Command Lookup Tool! Requires login, but nonetheless, a great resource for your Cisco engineers when you just NEED to know how the hell a particular command works.
  15. Priscilla Oppenheimer's Top-Down Network Design
  16. I've heard the folks at /r/networking are pretty legit.
u/zck · 20 pointsr/cscareerquestions

Get the book Working Effectively with Legacy Code. It's entirely how to deal with this situation, and might be better titled as How to Test Untestable Code.

Basically, the advice is this: get the system under test NOW, then you can make changes. If there's anything you need to change, try to get it unit tested. Whenever you break something, before you fix it, write a unit test.

Slowly, the system will become better. You'll still have a lot of hair-raising problems, but each time you add a test, you'll be more confident, because you'll know that some things still work.

The problem here will be if the professor cares enough to give you time to make any changes that aren't adding new functionality.

u/KernlPanik · 20 pointsr/learnprogramming

I'm a ~10 year sysadmin that has decided to rebuild my software dev skills that I haven't used since college. Here's what I did to reawaken that part of my brain:

  1. Harvard's CS50. I figured an entry level college course would be "beneath me" but it was a great experience and I learned a surprising amount. It's very entertaining as well so that made the "simple" parts fun to do as well.

  2. Read CODE by Charles Petzold. Great insight into the nuts and bolts of how computers work. Read through it on my lunch breaks while taking CS50 in the evenings.

  3. Read and do the problems in C Primer Plus. This is a great book for learning how to write in C, which is the basis for all modern languages and is still widely used today. Great starter book for anyone who wants to learn to program.

    3.5) After going through the last chapters of C Primer Plus, I realized that some of my math skills were not up to par, so I took this MOOC from MIT to supplement that. No idea if that's something you need.

  4. Here comes the fun one: The Structure and Interpretation of Computer Programs, aka The Wizard Book. This book is more about how to design software in general, and it is pretty difficult. That being said, if you can get through it then you have the chops to do this professionally.
u/I_make_things · 20 pointsr/AskReddit

Godel Escher Bach

It's ultimately about the self-referential nature of consciousness, but it explores so many fascinating concepts that I couldn't even begin to do it justice

u/neutronfish · 20 pointsr/cscareerquestions

One book that helped me a lot while starting out and which I highly recommend to any new student of computer science is Code: The Hidden Language of Computer Hardware by Charles Petzold, which starts out as a general interest book about the history of computing and then very quickly ratchets up into how modern computers, compilers, operating systems, and hardware drivers are built. You basically have to learn some discrete math and assembly language just to follow along, and by the end you have a really good idea of what happens under the hood when you run your programs and why.

u/schroet · 20 pointsr/cscareerquestions

This is a good start to get a taste of good code:

http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&qid=1456913184&sr=8-1&keywords=clean+code

Many developers recognize this practices and value them very much.

u/Nugsly · 20 pointsr/csharp

I'm going to start by assuming this may be maintained by another person at some point in the future. First off, naming. Although it is kinda targeted towards Java, the majority is directly applicable to C#. Clean Code. The underscores and you prefixing an abbreviation for the type should be changed. An example would be:

i_orderID

Changes to:

OrderId

because of the fact that it is a public property, and you've already told us it is an Int when you declared it. Doing this will allow others to maintain your code with less headache. https://msdn.microsoft.com/en-us/library/ms229045(v=vs.110).aspx is an MSDN article that goes over some of it.

Next, spaces in the folder names, you should avoid that for the same reason above, use PascalCase, no spaces, no hyphens, no underscores if possible.

You have no guard clauses in there. An example of adding one in would be (Line 31 'DataObjects.cs):

if (string.IsNullOrEmpty(displayLine1)) throw new ArgumentNullException("displayLine1");

Favor guard clauses over exception handling wherever possible. When you need to handle exceptions, handle them specifically. If the code you are calling can throw an InvalidOperationException, favor catching that over just Exception. Exceptions should be exceptional, not a common occurrence in your code, guard clauses help with that. Another example would be (Line 96 'Program.cs'):

if (File.Exists(s_directory + @"\Bricks.xml") { ...the rest of the code that uses that file here }

Use meaningful names. 'displayLine1' as a constructor parameter is ambiguous. Sometimes it makes sense to shorten some of the names as well; 'customerWhoPurchasedId' could just be 'customerId'.

In DataObjects.cs, you are returning '-1' as an error, I would use something more meaningful than a number. If you are going to use a number like that, use an enum so that you can read your code using friendly names, '-1' is ambiguous, but something like BrickSearchResult.Empty is not.

Style out of the way, now let's move on to data. You are a database guy. I would suggest using a database to store the data over an xml file.

Next. You are doing a ton of work in your application's main constructor. Move that code out of there, and let it initialize the app unimpeded. People debugging your code later will thank you. I would suggest using the Form_Loaded or whatever the Forms equivalent for Window_Loaded is.

On a general note, follow the principle of having each small piece of code do one thing, and one thing only. Your main class is also responsible for data access, it should not be. You should have separate classes for that, this is called 'separation of concerns'. Your CRUD operations should all be in the same class. Each class should have its own file whenever possible. So 'DataObjects.cs' would be split into 'Customer.cs' and 'Brick.cs'. Keep in mind that you can use folders in your solution as well to keep things a bit more organized.

You are welcome to PM me if you have other questions.

u/TheSojourner · 19 pointsr/sysadmin

Practice of System and Network Administration

http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668/

Worth every cent and more.

u/dgonee · 19 pointsr/cscareerquestions

wow. I'm surprised these two aren't listed yet:

Pragmatic Programmer - this one's at the top of my list. I think that every single programmer should read this book.

Effective Java - although it's written for Java there's some great fundamentals in there.

a lot of people also mentioned Clean Code - while some things in there are important, I personally don't agree with everything that Bob writes about

u/dantesus · 19 pointsr/web_design

Don't Make me Think A good design philosophy book. It's relatively old, but a lot of the ideas are still used today.

u/jschm · 19 pointsr/compsci

Effective Java by Joshua Bloch is a really good book and definitely worth reading if you're using an object-oriented language, not just Java. It helped me immensely when I was starting out with how to think about my code and my designs.

u/AnAirMagic · 19 pointsr/java

By Essential Java, I take it you mean Effective Java, right?

u/chra94 · 19 pointsr/pythontips

Automate the Boring Stuff taught me the basics and I recommend it highly. It's free.

If you encounter an error spend about an hour trying to solve it before asking for help. If you get an error with an error message from running the program you copy and paste the error message into a search engine and look for answers there. If the program behaves differently than you expect it too without giving you an error message you have probably made a mistake in your instructions to the program and these can be hard to find.

r/learnpython is great when you can't solve your problem(s), they're helpful as long as you say what you have tried, upload your code to pastebin.com and say what you want the program to do.

also when giving variables names please give them describing names. look at this example:

name = "chra94"

n = 6

name_length = 6

clearly name_length describes itself better than just n. Many beginners me included make the mistake of naming variables poorly which makes the code harder to read. good variables makes reading the code easier.

Be prepared to read documentations for both python but also tools (they're called modules or libraries) written in python for python. One day you might want to make a program that modifies or creates spreadsheets. There are libraries for that and even if you just watch a tutorial on how to use it it's easier to be able to search and read the documentation for the module than finding a tutorial specific for that one little thing you want to do that the other tutorial didn't cover.

Following the Automate the Boring Stuff book you will be able to make a rock, paper, scissors-game, making a number guessing game and such. Should you want more excercises you could look at codingbat over here at CodingBat for that.

Some day you might want to do a project. A program that's useful. Maybe it'll download the ten best wallpapers from r/wallpapers each day. Maybe you'll make a chatbot Slack or Discord or IRC. Anwyay. After having made a couple of programs that can be used over and over again by someone else than me I have realized that I have to plan much, much more ahead. My programs got messy, difficult to read, difficult to change and honestly I've lost control over them. I wish I had read Code Complete earlier. It praises planning your program thoroughly. According to some stats in the book mistakes uncovered after planning are between five to ten times more costly to fix than if they were discovered while the requirements for the program were figured out. (Theses stats are for small companies. Bigger companies can be as much as 100 times more expensive to fix.) TL;DR: Time spent planning is between three to ten times better spent than fixing stuff because you didn't bother to plan enough.

*TL;DR:** Do Automate the Boring Stuff untill you want to make stuff on your own and read chapter three of Code Complete.


Best of luck buddy and remember: Plan your projects ahead.

u/denialerror · 19 pointsr/learnprogramming

Just keep learning for now and focus on building your understanding of programming, rather than syntax or following convention. Despite what a lot of people tend to say, unlearning habits in not hard, especially as a beginner. Focusing too much on best practices early on will be an unnecessary distraction when you already have a lot of new things to try and get your head around.

When you get more proficient and start needing to worry about best practices, read Clean Code.

u/DoISmellBurning · 19 pointsr/compsci

Cormen is your friend.

Core text for the algorithms course I did as an undergrad - I highly recommend it.

u/tenpairsofsocks · 18 pointsr/learnprogramming

Taking a course will definitely help and I have a few book suggestions.

Intro to Algorithm
This is pretty much the holy grail on algorithms, used in many college CS courses.

Skiena's Algorithm Design
My personal favorite. Combines his Ph.D experience with real world problems.

u/dreasgrech · 18 pointsr/programming

First of all, for any software development questions you may have, I suggest you post your questions on Stackoverflow because the people there will surely provide you with answers.

Now, for a list of books I recommend:

JavaScript

JavaScript: The Definitive Guide; if you're new to JS, start with this one.

JavaScript: The Good Parts; not a beginner's book, but a must-read if you are going to use JS

If you are going to be using JS, you will most probably be developing using a framework, and for that I seriously recommend mastering jQuery because as they say, you will write less and do more!

CSS

CSS Mastery: Advanced Web Standards Solutions

Web Usability

Don't Make Me Think: A Common Sense Approach to Web Usability; the book that shows the users' perspective when viewing a website

Performance

High Performance Web Sites: Essential Knowledge for Front-End Engineers and Even Faster Web Sites: Performance Best Practices for Web Developers;if you want to get serious about performance for your websites

u/raarky · 18 pointsr/programming

i recommend code complete 2 as a must read for getting the fundamentals right.

http://www.amazon.com/Code-Complete-Second-Steve-McConnell/dp/0735619670

u/DeliveryNinja · 18 pointsr/learnprogramming

You mention you have a very experienced team around you, this is your best resource. When I started my first coding job, the people around me really helped me become a much better developer. Ask for advice when you are stuck, think about best practices and sit with them and do the code reviews together. If they are writing good code then use their code as a guide for your own. You will soon learn the skills for yourself and realise that it's not as daunting as it seems as long as you can code basic programs. Something you can do to get a better feel for how your basic programs create something larger is to get them to walk you through the architecture.

One thing I did when I started was ask my team leader where I could improve and he recommended me some books. Have a look at head first design patterns, clean coder and growing-object-oriented-software. These are Java based but are applicable to any language.

http://www.growing-object-oriented-software.com/

http://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

http://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124

u/Mansaber · 18 pointsr/unix

If you're new to C, read K&R.

Once you've done that (or if you already know C) then read THE book on Unix programming

u/myrrlyn · 18 pointsr/learnprogramming

https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

This book is an excellent primer for a bottom-up look into how computers as machines function.

https://www.amazon.com/gp/aw/d/0123944244/ref=ya_aw_od_pi

This is my textbook from the class where we built a CPU. I greatly enjoy it, and it also starts at the bottom and works up excellently.

For OS development, I am following Philipp Opperman's excellent blog series on writing a simple OS in Rust, at http://os.phil-opp.com/

And as always Wikipedia walks and Reddit meanders fill in the gaps lol.

u/daronjay · 18 pointsr/PHP

Working Effectively with Legacy Code

Might be a good place to start. Don't rebuild in one hit, isolate functionality, wrap with tests and abstraction layer, rebuild one component at a time

u/sallen35 · 18 pointsr/C_Programming

I'll suggest you for the Stanford Algorithm Part 1 and Part 2 on Coursera and its free while doing you'll get some assignment also and after the completion ,it will provide you a certificate .Here is my list of Online Courses to learn data structures and algorithms. It is sorted according to quality (in my opinion) :

u/keyofdminor · 18 pointsr/java

A classic text for this situation is Working Effectively with Legacy Code by Michael Feathers. Legacy code is a different ball-game than relatively clean code-bases, and has its own set of strategies. As it happens, there is a timely episode of the SE Radio podcast as well.

u/gwak · 18 pointsr/java

Does not include Java 8 but https://www.amazon.co.uk/Effective-Java-Second-Joshua-Bloch/dp/0321356683 fits the bill of the Java k&R

u/sid78669 · 18 pointsr/compsci

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.

u/JustBesideTheWindow · 18 pointsr/HowToHack
u/bmathew5 · 18 pointsr/learnprogramming

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

u/totemcatcher · 18 pointsr/linux
  • CODE: The Hidden Language of Computer Hardware and Software by Charles Petzold

    A ground up approach to understanding digital processing and transmission in a broad sense. I only recommend this book if you are looking for an intrinsic understanding of computing rather than merely a handle on using a particular programming language or operating system. By the end of the book you should have a handle on actually building your own computer, however it's actually an excellent "first book" for anyone interested in computing.
u/dud3z · 18 pointsr/blackhat

The dark side has lot of facets, it depends on what you want to achieve.

If you are already working on web applications and web in general, then you may want to start with the Web Application Hackers Handbook by Dafydd Stuttard and Marcus Pinto.

This is a very valid book and with your existent knowledge it will be a very interesting read: i may also advise you to read The Tangled Web by Michal Zalewski, this instead will give you a very in-depth look of browsers' quirks and their inner working, quirks you'll learn to exploit.. for science!

Then there is the world of binary reverse engineering and exploitation, my preferred literature on this is Hacking: the art of exploitation: keep in mind that the techniques there may be outdated, but the reasoning and much of the concepts are still valid. It's a very specific book with very detailed information and you are required to know a bit of assembler, C and very low-level stuff.

Happy hunting and good luck!

u/usernamesarethebane · 18 pointsr/java

Go read Clean Code: A Handbook of Agile Software Craftsmanship and write beautiful code yourself.

u/You11You · 17 pointsr/Design

https://www.amazon.ca/Dont-Make-Me-Think-Usability/dp/0321344758

The way I learned UI design quickly was to put together some designs and ask for critiques from designers. There used to be a website where you could get critiques for your designs (in exchange for giving critiques yourself).

u/Cohesionless · 17 pointsr/cscareerquestions

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:

  • Introduction to Algorithms, 3rd Edition: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844. A lot of people do not like this classic book because it is very theoretical, very mathematical, and very abstract, but I think that is its greatest strength. I find a lot of algorithms books either focus too much about how to implement an algorithm in a certain language or it underplays the theoretical foundation of the algorithm such that their readers can only recite the algorithms to their interviewers. This book forced me to think algorithmically to be able to design my own algorithms from all the techniques and concepts learned to solve very diverse problems.

  • Design Patterns: Elements of Reusable Object-Oriented Software, 1st Edition: https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/. This is the original book on object-oriented design patterns. There are other more accessible books to read for this topic, but this is a classic. I don't mind if you replace this book with another.

  • Clean Code: A Handbook of Agile Software Craftsmanship, 1st Edition: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882. This book is the classic book that teaches software engineer how to write clean code. A lot of best practices in software engineering is derived from this book.

  • Java Concurrency in Practice, 1st Edition: https://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601. As a software engineer, you need to understand concurrent programming. These days there are various great concurrency abstractions, but I believe everyone should know how to use low-level threads and locks.

  • The Architecture of Open Source Applications: http://aosabook.org/en/index.html. This website features 4 volumes of books available to purchase or to read online for free. It's content focuses on over 75 case studies of widely used open-source projects often written by the creators of said project about the design decisions and the like that went into creating their popular projects. It is inspired by this statement: "Architects look at thousands of buildings during their training, and study critiques of those buildings written by masters."

  • Patterns of Enterprise Application Architecture, 1st Edition: https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420/. This is a good read to start learning how to architect large applications.

    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.
u/Spasnof · 17 pointsr/learnprogramming

Awesome book Code , really helps you understand from a bottom up perspective. Super approachable without a CS background and does not need a computer in front of you to appreciate. Highly recommended.

u/TheHyperB3ast · 17 pointsr/programming

K&R. If you're in a programming 101 class that involves C, just buy this book unless your prof tells you otherwise.
---

K&R has the reputation it has because they did an excellent job of balancing between "experienced programmers can use this as a reference" and "newbie programmers can use this as a starting point. Let me clarify: K&R will not make you a better programmer, but it is an excellent example of what industry professionals would consider to be a good piece of technical documentation.

If you're going to ever work with APIs or large amounts of technical documentation about software, this book will mirror the experience you get reading "good docs". In short, learning C from this books does an excellent job of showing you how much you'll have to figure out yourself and what information you should be expected to be given to you when working in the industry.

u/Lapompaelpompei · 17 pointsr/learnprogramming

There are many courses on the internet. Coursera, Udemy, etc.. I recommend you to read at least a book about it. It really helps you to understand the logic and complexity. For data structures, I also recommend you to implement them by your self.

This is a very good book: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

This is the full MIT course: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/

I strongly recommend you to follow the course and read the book.

u/mohabaks · 17 pointsr/unixporn

Thanks ;). Not so skilled on that and my advice might be misleading; though I got a background in cs:This would be my suggestion for someone beginning.

u/Ruple · 17 pointsr/EngineeringStudents

>I have some questions about courses andsubjects for computer engineering ( Software Engineering)

CE and SWE are....a little different so I'll just talk to both a little bit.

CE is closer to Electrical Engineering specializing in Computers so you'd take more hardware oriented courses. Most CE curriculums [I've seen] take you through Circuit Theory, Electronics, Digital Systems, Signal Processing, Computer Organization (aka CPU design), Computer Networks, Embedded Systems, etc.

SWE is closer to applied computer science and is more about building applications and the software development process. So you'd start going through a lot of the early Comp Sci courses (Intro to Programming, Language Processors, Data Structures and Algorithms, Operating Systems, etc.) then you'd start leaning towards topics more closely related to building an actual piece of software like Software Project Management or Quality Assurance.

>Are they any books that you recommend to a complete noob ? Internet links ?

Who reads books?

u/jkwuc89 · 17 pointsr/webdev

IMHO, knowing the basics is vital. For JavaScript, I recommend buying and reading, "JavaScript: The Good Parts".

https://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742/ref=sr_1_1

u/Afro-Ninja · 17 pointsr/explainlikeimfive

It doesn't "know." Any logical operation (especially basic math calculations) can be broken down into binary digits, and a single binary digit (bit) can be represented as the presence or absence of electricity.

It's almost how if you were to build a sequence of pipes and valves, and pour water into the opening, the water would end up flowing through the same way each time. The pipes don't "know" where the water goes, it just happens.

A computer does the same thing but on a tiny scale with tiny electric pulses travelling through sequences of thousands of gates all connected to each other. Imagine that the buttons you hit on a calculator slightly change how the valves open and close. (or which opening to dump the water into) You hit enter, the water is poured, and the result shows on screen.

fair warning: I am not a hardware guy so this explanation is probably not 100% accurate.
If you have more interest in the subject I HIGHLY recommend reading this book: http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

u/chrndr · 17 pointsr/HPMOR

I wrote a quick script to search the full text of HPMOR and return everything italicized and in title case, which I think got most of the books mentioned in the text:

Book title|Author|Mentioned in chapter(s)|Links|Notes
:---|:---|:---|:---|:---
Encyclopaedia Britannica| |7|Wikipedia|Encyclopaedia
Financial Times| |7|Wikipedia|Newspaper
The Feynman Lectures on Physics|Richard P. Feynman|8|Wikipedia|Full text is available online here
Judgment Under Uncertainty: Heuristics and Biases|Amos Tversky|8|Amazon|
Language in Thought and Action|S.I. Hayakawa|8|Amazon Wikipedia |
Influence: Science and Practice|Robert B. Cialdini|8|Wikipedia|Textbook. See also Influence: The Psychology of Persuasion
Rational Choice in an Uncertain World: The Psychology of Judgment and Decision Making|Reid Hastie and Robyn Dawes|8|Amazon |Textbook
Godel, Escher, Bach|Douglas Hofstadter|8, 22|Amazon Wikipedia|
A Step Farther Out|Jerry Pournelle|8|Amazon|
The Lord of the Rings|J.R.R. Tolkien|17|Wikipedia|
Atlas Shrugged|Ayn Rand|20, 98|Wikipedia|
Chimpanzee Politics|Frans de Waal|24|Amazon|
Thinking Physics: Understandable Practical Reality|Lewis Carroll Epstein|35, 102|Amazon|
Second Foundation|Isaac Asimov|86|Wikipedia|Third novel in the Foundation Series
Childcraft: A Guide For Parents| |91|Amazon|Not useful if your child has a mysterious dark side

Also, this probably isn't technically what the OP was asking, but since the script returned fictional titles along with real ones, I went ahead and included them too:

Book title|Mentioned in chapter(s)
:---|:---
The Quibbler|6, 27, 38, 63, 72, 86
Hogwarts: A History|8, 73, 79
Modern Magical History|8
Magical Theory|16
Intermediate Potion Making|17
Occlumency: The Hidden Arte|21
Daily Prophet|22, 25, 26, 27, 35, 38, 53, 69, 77, 84, 86, 108
Magical Mnemonics|29
The Skeptical Wizard|29
Vegetable Cunning|48
Beauxbatons: A History|63
Moste Potente Potions|78
Toronto Magical Tribune|86
New Zealand Spellcrafter's Diurnal Notice|86
American Mage|86

As others mentioned, TVTropes has a virtually-exhaustive list of allusions to other works, which includes books that aren't explicitly named in the text, like Ender's Game

u/RetroTK2 · 17 pointsr/Unity3D

> I know programming

I have a checklist I usually bring out at this point :) You should know:

  • understanding different basic data types (ints, floats, bool, string) and how to manipulate them (especially strings)
  • understanding the difference between properties and fields.
  • If and switch statements
  • Ternaray Operators
  • Basic Mathematical Operators (*, +, =, etc);
  • understand the difference between = and ==, and not operators (!(true) and !=)
  • Advanced Mathematical Operators (+=, % for modulus , << left bit shift operator)
  • Arrays and Lists
  • Dictionaries and Keypairs
  • Understanding objects, classes and constructors
  • New Keyword
  • Access Modifiers and Static
  • Understanding references and null values
  • Inheritance
  • Indexers
  • Namespaces and using
  • Partial Keyword and why it's a good idea to limit the use of it
  • Abstract classes and interfaces
  • Delegates, Events, Action and Func
  • Understanding generics and using <T>.
  • Casting types with 'as' or direct and understanding the difference
  • Serialization
  • Comments and Regions
  • Threading
  • ref and out keywords and why they can be bad to use
  • IEnumerable and Yield Return
  • Enums and flags
  • Understanding Loops (while, foreach, for and do) and the differences between all of them
  • continue and break keywords and how to use them in loops
  • try,catch and finally
  • Understanding methods: void, return types and parameters
  • overloading methods
  • Knowing what the params keyword is and how to use it in methods
  • what virtual and override are and how they can be used

    If you confident you have all this you'll probably want to start learning about design patterns and decoupling techniques. This free online book is amazing, and I would recommend it to everyone:).

    Other books like Clean Code and The Art of Unit Testing have helped me a lot too.

    With coding, it because more about creating code that is easy to change. I would also recommend using StrangIoc along with MVC to achieve decoupled, clean code:)
u/fbhc · 17 pointsr/compsci

I recommend picking up a copy of either Programming Principles and Practice Using C++ or C++ Primer.

​

https://en.cppreference.com/w/ is a reference website, and is the goto resource for quick documentation lookups, etc. However, when learning C++ from scratch, a book is simply the best way to go.

u/My_6th_Throwaway · 16 pointsr/INTP

American amazon link

u/Nuka_Cora · 16 pointsr/web_design

I thought myself HTML/CSS with this book: http://www.amazon.com/gp/aw/d/1118008189/ref=redir_mdp_mobile

The book is design very well and eases you into everything with clear visuals.

And am still learning javascript with this sites regiment : http://javascriptissexy.com/how-to-learn-javascript-properly/

But I'm struggling finding the time to thoroughly understand it.

u/_Skeith · 16 pointsr/AskNetsec

Hey man! I work as Security Analyst - about a year away from graduating with my Bachelors.

I suggest you pick up the CompTIA Security+ Certification, as well as start learning the basics of Networks and how they function. Learn ports and protocols, as well as how IDS/IPS/Firewalls function. This will get you an entry level role as a Jr Analyst. I suggest you use [http://www.professormesser.com/security-plus/sy0-401/sy0-401-course-index/](Professor Messers Security+ Videos) This will teach you the basics of security work, networking concepts, threats, etc.

At the same time start listening to podcasts like Paul's Security Weekly, Down the Security Rabbit Hole, etc. As well as start reading blogs on hacking to get a feel for whats done.

Get a home lab and learn a few tools like Wireshark and Nmap for basic Security Analyst work - to learn how packets work, how they are structured, and how to scan pc's for ports and services. At the same time, focus on learning about threats and vulnerabilities (which are covered in security+).

If you want to get into PenTesting then you need a wide range of knowledge. Pick up and learn a few languages (master the basics and understand what the code does and how to read/interpret it). You need to know: PHP, HTML, SQL, Python (or Ruby), and a basic language like C, or Java.

If you want to dig deeper into PenTesting then start reading: https://www.offensive-security.com/metasploit-unleashed/

Good way to get into the Kali Distro and learn how to run Metasploit against vulnerable VM's.

Take a look at https://www.vulnhub.com/resources/ for books, and vulnerable VM's to practice on.

https://www.cybrary.it/ is also a good place with tons of videos on Ethical Hacking, Post Exploitation, Python for Security, Metasploit, etc.

Pick up some books such as

The Hacker Playbook 2: Practical Guide To Penetration Testing

Hacking: The Art of Exploitation

Black Hat Python: Python Programming for Hackers and Pentesters

Rtfm: Red Team Field Manual

The Hackers Playbook and The Art of Exploitation are great resources to get you started and take you step by step on pen testing that will allow you to alter explore the endless possibilities.

Also a good list of resources that you can learn more about security:

Getting Started in Information Security

Pentester Labs

Awesome InfoSec

Awesome Pentest

Overall experience and certification are what will get you into the door faster. Most employers will look for experience, but if they see you have motivation to learn and the drive to do so, then they might take you. Certifications also are big in the infosec field, as they get you past HR. And having a home lab and doing side projects in security also reflects well.

u/Rinnve · 16 pointsr/learnpython

You should read this book. The best explanation of how computers work I know of.

u/LunchNap · 16 pointsr/compsci


Here's your bible:
Introduction to Algorithms, 3rd Edition (The MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_apa_i_UbkDCb2H9VJ0B

u/savagehill · 16 pointsr/roguelikedev

I prefer Uncle Bob's view:

> It is well known that I prefer code that has few comments. I code by the principle that good code does not require many comments. Indeed, I have often suggested that every comment represents a failure to make the code self explanatory. I have advised programmers to consider comments as a last resort.

Other times he puts it more bluntly:

>Comments are always failures. We must have them because we cannot always figure out how to express ourselves without them, but their use is not a cause for celebration.

or

>"Every time you write a comment, you should grimace and feel the failure of your ability of expression."

I know it's not always practical, but I like Uncle Bob's extremely demanding perspective, because I feel it sets a really high bar and struggling to work toward it is something that stretches me.

If this is a wildly shocking view, I highly recommend picking up a copy of Uncle Bob's book Clean Code which I learned about from this IRDC talk. I saw that talk, bought the book, read it, and my views were changed. I now refactor a lot more and comment a lot less.

Uncle Bob's minimally commented code doesn't come cheap though, he spends a ton of cycles after the code works, retooling it specifically to make it readable.

Also, for the record, I ain't no Uncle Bob. Don't misunderstand me as saying I live up to his standards please!!

u/jonyeezy7 · 16 pointsr/AskProgramming

If you need to be neo to read code, then that code isn't written well.

Code is read by humans not machine.

So write code like a sentence.

I recommend you to read clean code by Uncle Bob. Something they don't really teach you in school.

u/drakonite · 16 pointsr/gamedev

You may want to narrow that down a bit, but okay, here are some highlights, with amazon links to help disambiguate.

u/ipe369 · 15 pointsr/learnprogramming

Not an expert, but heard this title being bandied around: https://www.amazon.co.uk/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742

u/therascalking13 · 15 pointsr/wow

There's a very popular management book about just this topic.

u/ethraax · 15 pointsr/programming

Introduction to Algorithms is an absolutely fantastic book. I've read it through a couple times. It's very well written and they have plenty of descriptive diagrams to help you intuitively grasp the different algorithms.

u/VampireCampfire · 15 pointsr/C_Programming

Either K&R's The C Programming Language which is often considered "The C Bible" and is written by the authors of C, or a more recently published C Programming: A Modern Approach are both excellent and comprehensive learning resources. I personally recommend the latter because I believe it is more relevant and includes almost, if not all, the information in K&R.

u/fsweetser · 15 pointsr/networking
u/87TLG · 15 pointsr/sysadmin

There's a lot of information you need and I highly doubt you're going to get it all from one post, one individual or one source.

If you know your IT director is leaving then stay on his good side and bend his ear a bit on how things work there. This will save the owed-beers and frantic phone calls when some shit hits a fan and you can't Google your way out of it.

As for what to learn, Windows or Linux, etc; If you want to stay with this company for a year or few then look at what they need. Find problems, research solutions, test them, present them to your boss in the context of how your solution can save money and/or increase productivity. Is every user emailing you requests for assistance? Setup a ticket system. What's your backup setup like? If you don't have one then you need to figure that shit out quick. Backups are boring and second-class to most people until they need to recover an important file.

I also highly recommend picking up a copy of The Practice of System and Network Administration. http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668. Most of us wouldn't recommend a tech book from 6 years ago but most of the information in this book is the non-tech stuff you need to know to do your job and do it well.

Oh, and keep lurking online and here in /r/sysadmin

Good luck.

u/FifteenthPen · 15 pointsr/learnprogramming

C++ Primer is amazing, but definitely not for beginners. Since you're totally new to programming, I'd suggest learning a bit of Python first to get the basics down, or if you're feeling more adventurous, pick up a copy of K&R's "The C Programming Language", as it's a great introduction to lower-level programming, and it'll make C++ a lot easier to understand.

Some good freely available online Python books:

Invent With Python

Learn Python the Hard Way

Learn Python the Hard Way is easier than it sounds, I assure you. I would definitely recommend starting with Invent Your Own Computer Games With Python, though.

A couple more useful things to know:

  • If you don't understand something, Google it. Stackoverflow, especially, tends to have a lot of good discussions on common pitfalls encountered by newbies.

  • If Googling doesn't clear it up, don't be afraid to ask for help. This very subreddit is a great place to do so when you get particularly stuck!
u/Ownaginatious · 15 pointsr/java

Read through this entire book before your program anything big.

u/borski · 15 pointsr/netsec

Two good books I'd recommend for getting started in exploitation:

u/ilikeUXandicannotlie · 15 pointsr/userexperience

Here are some things I (and I know others) have struggled with. I think the web is exploding with resources and information, so I don’t necessarily think we need to explain what a prototype is. There’s better places elsewhere to learn things about UX, but I think we could provide some good resources for not just people new to UX but everyone else too. I’m coming at this from what I wished I would have access to when I was trying to get into the field. I know that /u/uirockstar has some good walls of text that probably should be included as well. Feel free to suggest any changes to what I have here.




I really want to begin a career in UX/UI. What do I do?


Well, first it’s important to know that UX and UI are not synonymous. While many job postings combine them, UI is a subset of UX, just as research and information architecture are. UI is still important and if you can do both, you do increase your value. While many see UX as a research field at its core, the UX/UI title implies that it’s only about creating pretty things.

The first step is learning more about the field, which brings us to…



What kind of education do I need?


If you are still in school, there are more places recently that are offering courses in human-computer interaction. You can even try to create your own internships. There are very few UX specific schools, though they are starting to pop up, like Center Centre and General Assembly.



Yeah, yeah, that’s great. But I already graduated, so where do I start?


Any focus on people or technology can act as a solid foundation for learning UX. Because there has never been a set entrance path into the field, UX roles are filled with people from many different backgrounds. The most common degrees for those in the field though are design, psychology, communications, English, and computer science. link

There are a number of people in the field who are self-taught. There are tons of books, blogs, and designers (here are some helpful resources) which provide enough UX stuff to keep us all busy. When I first started reading about it, I quickly got overwhelmed because there was so much information available and most of it was intended for those who already had a pretty good grasp on things. The Hipper Element’s crash courses in UX and user psychology are great places to get a fairly quick overview.

There are books like The Design of Everyday Things by Donald Norman, 100 Things Every Designer Needs to Know About People by Susan Weinschenk and Don’t Make Me Think by Steve Krug that make for great first books.

UX Mastery has a great eBook for getting started, appropriately titled Getting Started in UX. Kevin Nichols’ UX for Dummies is both very readable, yet detailed. You can even buy the eBook if you don’t want people on the bus to think you’re a “dummy.”

Lastly, Fred Beecher has a very extensive Amazon list of recommended UX books, depending on what area you are looking to learn more about.



Great. I’ve read a whole bunch of stuff and have a pretty good idea how UX works. Now how do I get someone to hire me so I can gain experience?


Hey, easy there. While, yes, there are lots of UX jobs out there, very few are entry level and not many employers will hire someone who has only read about it and not actually done it. You can’t get a job without experience and you can’t get experience without a job. I know. Frustrating, right?

You have to prove that you can do it. One way to do this is site redesigns.

Go find a website that lacks in it’s user experience and figure out how to fix it. Maybe it’s a small business down the street from you or maybe it’s a feature on eBay you think could be better. Redesigning sites is a good way to practice a process and make mistakes on your own time. If you can involve the owner from that small business down the street, that’s even better because then you can get a sense of the customers (users) that you will be designing for.

Once you have done this, you have (some) experience! Start a portfolio and add to it!



But I have a resume. Why do I need a portfolio?


Resumes are great. But resumes won’t get you a job starting out. It’s a million times more effective to show potential employers what you have done, rather than showing them a resume showcasing that you are a team player and proficient in Microsoft Office. But you should still have a resume that outlines your UX skills.



But I’ve never worked in UX! What should I put on my resume?


You don’t need to put all of your old jobs on your resume if they are unrelated to the field. Most places still want to see some work history so they know you haven’t been living in a cave for the last four years, but they don’t care about how you sold vacuum cleaners or trained circus horses. Maybe you can relate some crossover UX skills to your previous work.

Back to portfolios. They are a lot like elementary math class in that you want to show your work. Potential employers are much more interested in how you made a design decision rather than the final result. If your portfolio just has a bunch of fancy wireframes, that doesn’t tell them how you took specific personas into account and you are simply showing them something that looks pretty. And just because it looks pretty doesn’t always mean it makes sense.



Okay. I have a portfolio with a few unsolicited site redesigns in it.


Congratulations! But I have some bad news. Are you sitting down?

No one wants to hire you yet. You haven’t worked on any “actual” projects that showed how your UX skillz helped a business. I know I suggested you do site redesigns to get practice and you should because that is work you can take to a nonprofit or another small business and say, “here are some trial runs that I’ve done that prove I know what I’m doing and now I can help you for free in exchange for adding it to my portfolio.”

They’ll probably be skeptical and say, “hmmm… I don’t think my website needs this newfangled user experience you speak of and—wait did you say free?”

You both get something out of it and you’re doing it pro bono, which relieves you the pressure of making one tiny mistake. (There is a great site called Catchafire that matches non-profits all over the country with people looking to donate their time and skills.)

Once you have a portfolio displaying your work and some experience, start applying! But there is one more aspect that goes into getting hired and that is the people who will hire you.




Ugh, but isn’t networking just using people for my own professional gain?


I had this same mindset and it probably delayed my entrance into the field. I wanted to rely only on the quality of my work and trusted the rest would follow. I avoided networking and meeting people in the field because I didn’t want it to seem like I was only mooching for a job.

But the fact is people are altruistic in nature and like helping others. Many people also enjoy talking about themselves, and those are the two main principles of an informational interview. You’ll also find that people are excited to help others get started since they remember how difficult it was (see: this blog post).

It wasn’t until I started getting those informational interviews and talking with people at UXPA and MeetUp groups that I learned another side of UX, but also got more familiar with more hiring managers or those that knew them. Whenever possible, people will hire those they know and like. Until you get out and start shaking hands and kissing babies, you will be just another faceless name in a stack of resumes.

Meeting with recruiters/staffing agencies is also a good route as they make money by finding you a job, so they have a vested interest in giving you constructive criticism.




I've heard that you have to live in a big city to get a job in UX.


Move. Just kidding. But while it’s true that larger cities like New York, San Francisco, and Seattle are full of opportunities, there are plenty of other places around the country that have jobs. Here are the top 20. If you live in a tiny city, expect a tougher time finding a position.



Okay, I got an interview. How do I not mess this up?


Some great advice is to go all UX on your preparation and treat the interviewer like a user.

.......to be continued.



Blogs:

u/NullEgo · 14 pointsr/AskComputerScience

The biggest hurdles I had motivating myself to work on a project was never coding itself. It was always setting up the compiler, IDE, environment, finding something to work on, etc. The biggest one for me is blank page syndrome.

You don't need to convert to linux if you don't want to but it is good to get some experience in it if you can. I spent sometime setting up a headless Ubuntu server to manage my torrents and be network storage. It took a lot of time starting from scratch but the experience has helped me out.

http://www.ubuntu.com
http://www.reddit.com/r/linuxquestions
http://ubuntuforums.org/

If you want to continue with Java (which is a good choice). I believe the most popular IDE is Eclipse. It has great plugin support and has been used everywhere I've been. You can use it for development on android phones as well if you want to play around with mobile development.

http://www.eclipse.org
http://developer.android.com/tools/sdk/eclipse-adt.html

If your college is like mine, most of the later courses in computer science will not involve much coding at all but will involve a lot of math and knowing popular solutions to common problems (sorting, searching, graph theory, combinatorics). If you feel like you need to brush up on a language, there are a lot of web resources and books to help you.

http://www.codecademy.com
http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683
http://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=sr_1_2?s=books&ie=UTF8&qid=1382580434&sr=1-2&keywords=head+on+java

Computer science and software development is a broad field which makes scaling it daunting at times. The only way to make it less daunting is to just dive in and do it. Pick a project and work on it. You will encounter problems you have no idea how to solve and that's great because now you've found something you can learn (usually through Google).

Solve problems in manageable bits. If you try to implement your whole program at once it will seem impossible. Implement small portions of your project at a time. Trying to create a Java chat client? Just work on getting some basic sockets to work and build a library you'll be able to use going forward. This will make the goals seem manageable and help you modularize your code. It helped me with not feeling overwhelmed about my project's scope.

I hope I didn't sound condescending. I just wanted to share some things that have helped me. I don't think you are in a bad spot, you just need to stay motivated and find some things to work on to help you learn. If you have any specific questions I can try to help out, but there are other people on this sub that are far more knowledgeable than me.

u/Manitcor · 14 pointsr/dotnet

There are some key concepts you want to get down if you really want to make the most of .NET

  • OO design and basic patterns
    Design patterns are used over and over again in OO based systems. A good understanding of what they are for, and how they tend to be used will be helpful when trying to understand key framework extensions and 3d party libraries. I like to point people at Head First Design Patterns. The opinions on design patterns in this book are a bit dated and the examples use Java syntax but they are all relevant to the .NET world and will go a long way to understanding how class names and object structures are used in OO systems.

    IMO One of the biggest concepts you'll need to understand in OO currently is the Inversion of Control pattern (also referred to as dependency injection) and the frameworks that provide it. Most modern .NET applications leverage some kind of dependency injection to simplify development and make unit testing and porting of classes easier.

    NOTE: I understand many folks in the PHP world feel that PHP is a full OO system. While they have made strides in this area it is not a fully typed OO system. It's a procedural system twisted to provide some OO features.

  • Syntax
    This is easy, just review MSDN docs and samples. The biggest different you will see in the .NET world is a different opinion in general on casing of object and method names.

  • Frameworks
    This is the part that seems the most overwhelming IMO. The language itself is fairly easy but understanding the huge amount of 1st and 3rd party libraries, frameworks and tools can be daunting. Since you come from the PHP world I am going to assume you are most interested in web based applications. What I would recommend is to pick a set of tools for your web stack and learn them. Once you understand the key pieces of a web application and how they interact you can start picking and choosing different components to meet your needs. I am going to suggest you start with the following stack to get started with a web application, this is the same stack I use for most of my clients making smaller functional websites or simple content driven systems.

  • .NET 4 (you can do 3.5 but really just go with the latest)
  • Core Web App - MVC (3 or 4)
  • Dependency Injection - Unity 2.0 or 2.1
  • Data access - Entity Framework
  • Application Security - .NET Membership Provider (there is a newer slightly better framework by MS but I cannot recall the name at the moment)
  • Consuming 3rd party services - WCF
  • Exposing your own services REST - MVC (since you are already using it for pages)
  • Exposing your own services using multiple protocols/data formats - WCF
  • XML Processing - Linq and Lambda's. Also be aware of XmlTextReader and XmlTextWriter for targeted high speed forward-only processing.
  • Configuration management - build in web.config with CSD for complex configuration structures beyond what appsettings can provide.

    Key Concepts for Modern .NET Apps

  • Generics
  • Lambdas
  • Linq
  • Closures
  • dynamic typing
  • threading

    Some basic tools to help you:

  • dotpeak - provides detailed assembly information and some decompilation.
  • Assembly binding log viewer - helps troubleshoot dependencies by logging internal CLR calls to dependent libraries.
  • MSBuild - Build management and orchrstarion. This is the system used internally by Visual Studio for building projects. It's a command line tool so you can build projects even without visual studio. A basic understanding of MSBuild makes it fairly easy to use any IDE or text editor you like for .NET development. I do however like VS2010 or 2012 as it goes a long way in helping you code and understand .net.

    Edit: Now with more links.
u/gamefaff · 14 pointsr/sysadmin

> Crankys Guide to Sysadmin

I would honestly read that. It would make a great no-bullshit addition/supplement to something like The Practice of System and Network Administration.

u/mdavidov_duo · 14 pointsr/IAmA
u/osirisx11 · 14 pointsr/math

If you like stuff like this you may be interested in my favorite book: Godel, Echer, Bach: The Eternal Golden Braid:

http://amzn.com/dp/0465026567

Edit: Also see the great MIT course with video lectures:

http://ocw.mit.edu/OcwWeb/hs/geb/geb/

u/kotajacob · 14 pointsr/learnprogramming

I'm confused do you want someone with a native American accent, a British accent, or and American accent?


(Also in general videos tend to be a poor medium for learning the C language. Most learn from books like this)

u/cutestain · 14 pointsr/personalfinance

Personally I am a UX generalist and work as a freelancer for early stage startups. I don't seek work on "game changer" projects like Fitbit, Snapchat and Pokemon Go but instead projects to improve processes that make current businesses more efficient and profitable. There is so much money to be made on these projects.

I design the app from top to bottom.

  • User Interface (UI) -icons, forms, images, microcopy, etc.
  • Graphic design - typeface,colors, sizes, etc.
  • Information Architecture (IA) - layout on a single page
  • Style guide & Pattern library - UI & IA in aggregate
  • Usability testing -feedback from users on your design
  • User experience research - what does the business and the market place need

    Here is some of the knowledge one would need to be successful:

    App Design Basics

  • Google Material Design
  • Apple's iOS Human Interface Guidelines
  • Stephen Anderson's Seductive Interaction Design

    Overall Concepts

  • Don't Make Me Think by Steve Krug
  • John Maeda's Laws of Simplicity

    Psychology for microcopy (short instructions) and influence in design

  • Richard Thaler's [Nudge] (https://smile.amazon.com/Nudge-Improving-Decisions-Health-Happiness/dp/014311526X?sa-no-redirect=1)
  • Anything by Dan Ariely
  • Mental Notes Cards by Stephen Anderson

    Software needs

  • Sketch by Bohemian Coding $99/yr for basic design work
  • Zeplin for conversations with clients and developers $15/month
  • Proto.io $29+/month for prototypes (shows transitions on and between screens)
  • The Noun project for finding icons $99/year
  • Zoommy App - for finding high quality Creative Commons 0 (CC0, free) images $4.99 once

    Places to see samples of work

  • Dribbble
  • Codepen.io

    My general suggestion is to start by designing something to solve a problem you care about for a business/industry you would want to work in. Don't expect perfection but practice constantly. Build your process and constantly improve for 6 months to 1 year. Then you're probably going to confidence, skills, and samples of work that are good enough to get a job.

    Edit: formatting always gets me
u/Alastair__ · 14 pointsr/cpp

I would recommend C++ Primer 5th Edition http://www.amazon.com/Primer-5th-Edition-Stanley-Lippman/dp/0321714113 to get up to speed with C++11 then probably Stroustrup afterwards.

u/planiverse · 14 pointsr/sysadmin

I think you need to keep an extremely open dialog with the COO. She's your boss. But she's likely hoping you become a trusted adviser rather than someone who needs to be managed.

  1. You need to let her know that your feeling uncomfortable with the new role and responsibilities, and let her know you have a plan to move forward.

    Don't go in there helpless. But don't hide your deficiencies either. If you want to grow, she will help you do it. But you need to be self-reflecting and have ideas as to how to move forward.

    The plan itself will come in the next suggestions.

  2. Try to piece together as many past projects as you can remember. Recall the goals you were trying to achieve, the general timeline, and any roadblocks along the way.

    Reflect on what was successful, and what could have gone better. Get a feel for the general process you defined. Could you have communicated the goals in a more organized fashion? Could you have defined milestones to help set management expectations? Should you have explicitly mentioned certain things weren't goals? What alternate plans where there, why were they rules out, and did management know about them? Were they properly budgeted? Was there adequate testing? Was it prioritized properly?

    Do this for every singly project you can remember, then focus on identifying the strengths and weaknesses of each rollout. The strengths are what you were good at doing. The weaknesses were what you were bad at.

    It could be as simple as "You know, looking back at this rollout, it all feels like one big step to me. I'm having trouble breaking them apart into steps, so it's hard to know when one piece of the project is done." You also need to identify why it's a problem and could get in the way of the project.

    Look for patterns, and lay them bare. She'll be aware of some things and not on others. But you're demonstrating a clear willingness to grow, and that your solutions aren't just grasping at straws.

  3. Research training options.

    When you assess training options, you need to realize what you actually need. Do you need a class on project management, where you can ask an expert questions, or should you focus on ITIL standards, maybe you just need to start with a book, or maybe a book about modern it departments, or just a professional community.

    Your project successes and sore spots, as well as your own comfort level will answer this question.

  4. You asked about tools and tips here. That's important, but if you don't know what problems you're trying to solve, you can't choose an effective tool.

    For any suggestion here, make sure you can justify its efficacy. How will the tool solve something that went wrong with a project?

    Maybe the tool isn't a program, but a process . . . A process that you're technically building up by reflecting on project results and starting the dialogue.

  5. Define your role. What do you perceive your role to be now? What do they perceive your role to be now? What is the immediate goal for your role? What do they expect of you in 5 years? Where do you expect to be in 5 years?

    They might want you to stop break/fix entirely. You won't be getting an assistant, but you'll be put in charge of someone with their own role, goals, and projects. THEY handle break/fix, rolling out an update, deploying a project.

    So when a rollout moves past configuration and basic veirfication, they're role is to test it. Then give it to the people you direct. Then give it to everyone. They're not assisting you, they're following their own objectives within the parameters of their job description.

    Maybe they see you as becoming a CIO type in 5 years: the budget, vision for the company, etc. will fall on your shoulders. You'll have a team of people under you doing technical work, while you handle technology from the business perspective. And maybe that's not what you want.

    You might want to stay technical and specialize. You'll need project management skills as a Sr. admin or a manager, so your short term goals align. And they're not big enough for a CIO now anyway, so there's no harm.

    But your building the expectation that, once you grow large enough, there WILL be someone over you. Because that's not what you want.

    ------------------------------

    It's all about being comfortable, open, and trying to improve. Right now, you're deep into the learning phase. Own it. Everyone will respect you for it.
u/hso · 14 pointsr/sysadmin

Congrats at getting into NEU. After reading a bit about the school, it sounds like you had to do work hard in your schooling to get into it.

On becoming a sysadmin, be patient. It's going to take a while. However, here are a few things to keep you busy:

exercise 1:

  1. Tutor yourself in vim (vimtutor) or emacs (Ctrl-h followed by t). They are
    your world. DO NOT code in an IDE. Code in them all the way through
    your degree.
  2. Make a custom vim or emacs rc that has syntax highlighting and
    personalizes your editor to you. Become a power user in whatever your
    editor of choice is.
  3. Make a custom profile and rc file for your shell (choose either bash
    or zsh, but if you go with zsh, you have to learn bash anyway) to
    customize your shell to your liking

    exercise 2:
  4. look up the man pages on the commands below and bash to learn what they do (when you type
    things into your shell that the oh-so-helpful! interwebz tell you to do, you should always understand
    what they do before your run them)
  5. open three terminals
  6. in one terminal run:
    strace -eread=all -ewrite=all -f nc -l -p 18100 127.0.0.1 > server_out 2>&1
  7. in the other terminal run:
    strace -eread=all -ewrite=all -f nc -v -v -n -w 1 127.0.0.1 18100 < /etc/profile > client_out 2>&1
  8. as root run: tcpdump -s0 -ni lo -w /home/conversation_out.pcap
  9. use vim or emacs to scroll through the file and annotate everything you see in
    the file until you understand all of it and use wireshark to annotate everything
    that is happening on the network in that pcap you had tcpdump write out all
    the way up the OSI stack

    exercise 3:
  10. look up the man pages on the command below and bash to learn what they do
  11. open a terminal and run:
    strace -eread=all -ewrite=all -f wget -qO /dev/null www.google.com > wget_out 2>&1
  12. as root run: tcpdump -s0 -ni lo -w /home/wget_out.pcap
  13. use vim or emacs to scroll through the file and annotate everything you see
    in the file until you understand all of it. include everything that happened between
    your host and google (you don't know google's internals so just assume they're
    running an apache server) over the network in the annotation. study a webserver
    (apache, lighttpd, nginx) in debug mode with strace to understand what happened
    on the other side of the network connection and use wireshark to annotate everything
    that is happening on the network in that pcap you had tcpdump write out all the way
    up the OSI stack

  • learn the config files and log file formats for major Open Source software (programs such as apache, a syslog daemon, postfix, BIND, ISC DHCP Server, xinetd, ntpd, etc.)
  • learn how to monitor these programs and servers running them (nagios, graphite) and the networks they communicate over
  • have basic understanding of cvs, rcs, git and svn. have advanced understanding of git or svn or both. store ALL the code you work on from here on out in your own software repo and keep it backed up.
  • learn how to compile open source programs from the ground up and build your own packages (both rpm and deb formats)
  • learn about puppet, fabric, capistrano, chef, mcollective
  • learn about rabbitmq and stomp message brokers
  • learn file permissions, user/group ownership, absolute and relative paths and how these translate to structures in the filesystem
  • learn perl compatible regexes inside and out
  • learn how to script in a bourne compatible shell, perl, python and ruby and get really good at scripting in shell and one of the other languages
  • learn how to read C and be able to write simple programs in C. use gdb to single step some of these programs (both lines of C code and x86 instructions) and learn how they interact with the stack, heap, environment, kernel, c-library functions etc.
  • play with sqlite, postgres and mysql to get a general idea of how databases work
  • pick a web framework and set it up in a webserver, learn MVC and use a database back end as you develop some apps. you could track your homework or whatever with the apps you make but the point is learning. any of rails, django, pylons, sinatra are fine. starting with sinatra and sqlite is probably easiest.
  • learn how to harden your operating system so that ONLY the services (daemons) that the OS needs are running
  • learn how to write iptables rules to protect your host
  • get one or two trusted friends to attack the host that you've hardened and see if they can compromise it
  • learn the basics of all these protocols and their addressing schemes (where applicable) and any crypto they use: IPv4 (TCP, UDP, ICMP, ARP), IPv6, HTTP, NTP, SMTP, POP, IMAP, TLS/SSL, SSH, NFS. Get familiar with the network packets that all of these protocols generate.
  • learn the OSI stack and where protocols and various types of network gear live in the stack (hubs, switches, routers, firewalls, load balancers). all sysadmins should have CCNA level knowledge or better when it comes to networking.
  • learn how to debug and troubleshoot. those friends that attacked your system for you? have them break something on your system. then you go in and figure out what's not working and fix it. do this again and again. if you can find some like minded folks then work together on all this stuff and learn from each other. good sysadmins work in teams to make things happen. we don't teach this in college or secondary ed. the work place ideally (hah!) is all about groups of people pulling off the impossible together.
  • learn how to search in search engines with all the advanced operators that average folk don't use. search engines save you when you run into some weird error message you've never seen before that others have.
  • hang out on serverfault and stackoverflow and learn from others
  • learn the following commands/programs (and what type they all are. 'type' is your friend): ack-grep, apt-cache, apt-get, ar, as, autoconf, automake, awk, base64, bc, bison, bzip2, cal, cat, cd, chgrp, chmod, chown, cpio, curl, cut, date, dd, df, dig, dpkg, du, echo, env, eval, exec, exit, expr, false, fg, find, flex, ftp, fuser, g++, gcc, gdb, gnupg, grep, gzip, head, help, history, host, hping3, id, install, iostat, jobs, kill, killall, last, ld, ldd, less, lftp, ln, ls, lsof, make, man, md5sum, mkdir, mknod, mktemp, more, mv, nc, netstat, ngrep, nice, nm, nmap, nohup, nroff, nslookup, ntpdate, od, openssl, pax, pcregrep, ping, pkill, ps, pstree, pwd, readelf, rm, rmdir, rpm, rsync, scp, screen, sed, set, sipcalc, size, sleep, socat, sort, ssh, stat, strip, stty, su, sudo, tail, tar, tcpdump, telnet, tmux, top, touch, tr, type, uname, uniq, vmstat, wc, wget, who, whoami, xargs, yum, zcat
  • learn how to use shell script snippets and perl/ruby/python oneliners to make yourself more efficient at the commandline

    Read these whitepapers:

  • http://labs.google.com/papers/gfs-sosp2003.pdf
  • http://labs.google.com/papers/bigtable-osdi06.pdf
  • http://labs.google.com/papers/mapreduce-osdi04.pdf

    Buy this book and learn it inside and out. It is your bible.

    If you do all this and learn it well, get a couple years experience under your belt (frequently there are computer labs that students can work in in college, that is one place to go) and then move to Silicon Valley or some other hub (sounds like you'll already be in Boston--there should be opportunity there). You'll never run out of work and you'll have the opportunity to try to work for the companies that make directly make money from their computing systems instead of being inside an IT shop that is a cost center in some company that does not appreciate you.
u/therookie001 · 14 pointsr/cscareerquestions
u/goodbyegalaxy · 14 pointsr/hardware

Code: The Hidden Language of Computer Hardware and Software

As the title implies, it's not just about hardware, it goes into how software is written for hardware as well. But it's a really cool book, takes you from the very basics of circuitry (a battery, a light bulb, and wire) in the first chapter, and building only on things taught in the book gets you to a fully working computer.

u/Goldenu · 14 pointsr/sysadmin
u/simonsarris · 14 pointsr/javascript

Read JavaScript: The Good Parts by Crockford. He goes over structuring JavaScript in an OOP fashion. More generally it's a great book that will bring your understanding of JS from intermediate to the beginnings of expert.

u/lasthope106 · 13 pointsr/C_Programming
u/Insindur · 13 pointsr/csharp

First off, well done on getting one of your first apps out there. It's always a daunting step, especially when you're a beginner.

Some general things that will help you improve your current design and any other app you choose to create going forward:

  • Learn about SOLID programming principles. I won't go into too much detail because there is a wealth of resources out there to explain the basics better than I ever could such as this. Once you understand what each of the letters in the acronym means, you can use it as a framework to assess your own design.
  • Design patterns can also be a valuable tool for a developer (though use with caution, if not used properly they can make your application needlessly complex). This site has some simple examples available specific to C#, but you might want to check out some material on object-oriented design first to get a better understanding of WHY we use patterns in the first place. The Head First series is quite a beginner friendly option in this regard Book 1 Book 2.
  • Take a look through the official Microsoft C# guidelines, I noticed a few instances where you could improve the readability of the code based on their checklist (using implicitly typed variables with the var keyword where applicable, using string interpolation etc, using auto-implemented properties for your classes, meaningful variable names etc).
  • Look up DRY (Don't repeat yourself), and KISS (Keep it simple, stupid), it will help you write shorter, clearer methods. I can see a few places in your code where you could decompose certain operations into separate methods.
  • Treat user-input as an unpredictable spawn of Satan that it is: using decimal.TryParse(...) instead of Convert.ToDecimal(...), try...catch blocks, you always want to validate user-input as far as humanly possible.
  • BONUS TIP (though some may disagree with me here): try ReSharper out, it will give you valuable suggestions while coding that you can otherwise miss. Even after 8 years of experience with C#, it helps me out tremendously.
u/Suitecake · 13 pointsr/learnprogramming

Debugging is investigation. Trial-and-error is voodoo.

See "programming by coincidence" in The Pragmatic Programmer, as well as this SO post.

u/scandii · 13 pointsr/AskProgramming

as a beginner you're stuck in a position where you want to learn how to do things, but also how to write them. i.e you don't only want to paint a painting, but you also want it to be pretty and admired.

for programming there's a lot of schools of thought on this subject, some guys prefer test-driven development, others domain-driven design.

some think comments outside of method parameters are good coding praxis, others think it's a code-smell because if you have to explain your code you probably wrote it in a way that makes it difficult to understand.

some think patterns are for hipsters, others are of the correct opinion (ahem) that they are standardised solutions for common problems.

all in all, if I could go back in time 15 years when I started programming, I would read the following if they were available at the time:

https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215

Domain-Driven Design is the concept of breaking your code into logical real world units and bundling your code around these objects so that it makes sense to program if you understand the real world your program is mirroring. i.e if you're making a fruit shop program, you might have a fruit seller, a register, a fruit warehouse, a process to deal with ordering fruit etc.

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

Clean code talks not so much about the architectural patterns (outside of test-driven development) but rather what's good and bad about code at it's core. i.e

if(fruitStand.Amount < 5)
{
fruitHelper(fruitStand, 3434)
}

vs

if(fruitStand.Amount < dailySoldAverage)
{
OrderNewFruit(fruitStand, wholesaleDiscountCode)
}

outside of that, I think you'll find a lot more resources by simply researching the concepts these guys talk about. programming is constantly changing, as long as you have the fundamentals in place as these guys talk about you're golden as long as you're willing to learn.

u/LyndonArmitage · 13 pointsr/coding

Don't forget The Pragmatic Programmer

I can highly recommend the Artificial Intelligence for Games book mentioned in this article too, has many useful techniques written in an easy to understand manner.

u/Deco21 · 13 pointsr/java
u/uzimonkey · 13 pointsr/gamedev

I wouldn't call this game "finished," not even in quotes. Implement scoring correctly with display in the game and disappearing/respawning balls, correct deflection (as if the paddle were rounded), smoother AI motion and correct keyboard input (it's backwards and seems to rely on autorepeat). Then the game will be a "finished" pong game.

I can't comment on the Javascript code really, but if you're just learning Javascript, I really recommend reading Javascript: The Good Parts. It's a very short book on how Javascript really works, with no real attention given to irrelevant APIs (to game programmers) and the like.

I also recommend looking at one of the several HTML5 game libraries out there. I'm using ImpactJS, but it costs money. If you want something free, you could try looking at Crafty. They abstract a lot of things and you can focus on making games, and not with the details of HTML5 APIs.

u/mbond65 · 13 pointsr/sysadmin

I keep seeing this book mentioned on this sub reddit, I haven't read it yet but it looks like what would help you: http://www.amazon.co.uk/The-Practice-System-Network-Administration/dp/0321492668

u/hell_onn_wheel · 13 pointsr/Python

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!

u/JamesKerti · 13 pointsr/ProtonMail

I don't work for ProtonMail but as someone who worked as a part of a development team, I feel like I have something to contribute to this discussion.

Getting the Bridge done as quickly as possible isn't simply a question of throwing as many people as they can at the problem.

First, it's an established fact in the software world that shoving more programmers at a project can actually make things worse, rather than better.

Secondly, not every developer brings the same thing to the table and has the same expertise.

The ProtonMail web interface uses one technology.
The encryption itself uses another, plus an even deeper level of theoretical understandings.
ProtonVPN is a completely different technology.

To stick with the house analogy, suggesting that building ProtonVPN means the Bridge isn't a priority is like suggesting that the plumbing in the house must not be a priority because you aren't pulling the carpenters off their jobs to help get the plumbing done as soon as possible.

u/reckoner227 · 13 pointsr/java
u/roo-ster · 13 pointsr/sysadmin

This was famously used by the lead manager of the IBM OS360 development project, to explain why adding more programmers wouldn't make it possible to deliver the OS, sooner.

[Edit: For anyone who's interested, he wrote a book called The Mythical Man-Month on this exact topic.]

u/scottm · 13 pointsr/sysadmin

I recommend The Practice of System & Network Administration. Next is probably the manual or a book about whatever monitoring system you're using (and spend the time you would have used to read another book to ensure you're monitoring everything). After that it depends what you're doing (busy public websites? Office IT?)

u/BuilderHarm · 13 pointsr/learnprogramming

I've heard good things about Head First Java.

I haven't read this one, but I have read their C# book, which I highly recommend.

u/skrepetski · 13 pointsr/sysadmin

For those too lazy to find it, http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668 is the book on Amazon :)

u/expedient · 13 pointsr/programming

Not a video, but Code: The Hidden Language of Computers by Charles Petzold is really great.

u/sintos-compa · 13 pointsr/programming
u/randomguy186 · 13 pointsr/sysadmin

> No one else even has admin level access-- except me, very recently, with a big fight.

If this fight was with your current "computer guy," then you have big problems. They may be political, or technical, or security; he may be just offended that a family scion is encroaching on his "turf," or he may be afraid that someone will see his incompetence, or he may be disgruntled by the whole employment experience and planting some deadman switches. Take some time to mend fences; emphasize your need to learn this area of the business, and that you don't intend to displace him, and that the more you learn about what he does, the more you, as a future owner, will be able to advocate for the expenses necessary to keep "IT department" operating smoothly.

But also make it clear that the guy who pays the bills has placed you in charge, and that while you want to hand him his paycheck indefinitely, you are the guy signing the paycheck. Things are going to change, and he needs to get on board with that. He may not be willing to accept this change, in which case you will, unfortunately, have to quietly start planning to replace him.

Give him a chance; he may come around. It sounds like for a long time he's been able to run the "IT Department" however he wanted to, so this is a huge life change for him. I can't emphasize enough how much you need to make clear your loyalty to him, but that the price for that loyalty is his loyalty to you the other members of management.


> We have at least 8 computers still running XP.

Is this because computer guy didn't want to replace them (bad) or because users didn't want them replaced (still bad, but not computer guy's fault)?

> He keeps everyone's passwords on his phone.

This is almost certainly because of employees who think he should know everything about computers, including their password. I'd start with a culture change among employees that passwords are secret; that no one, not even the owner, should have their password; and that writing down or sharing a password should be a fireable offense. However, you need to be sure that passwords are easy to remember.

> Am I wrong to be thinking we shouldn't be having these frequent crashes/problems?

No, you're not wrong. Review your support agreement in detail. Start keeping meticulous records of the problems you're having and the impact to the business, in terms of number of users affected, lost hours of work, and lost revenues. Notify the software company of each problem. When you get to three problems, you need to politely but firmly request an escalation to someone who can address and prevent these problems systematically. There's a good chance that the software company will report back that these problems are the results of past decisions your company has made in contravention of the software company's recommendations.

> yelling at people

Does your company have a culture of yelling at people? Does the owner yell at people? Do managers yell at people? If so, then he's merely following his leadership. This is a culture change that you will have to work on, quietly and calmly, but forcefully. If / when leadership doesn't manage by yelling, then I would make it clear to computer guy that he gets one free yell, but a second one will result in harsh disciplinary action. If the job is that frustrating, get him a heavy bag for the server room and tell him "Whenever our employees are too stupid for words, excuse yourself, tell them that your boss 0110100101110100 told you you have to do something, and go punch the bag." This sounds like it might also be symptomatic of the end users expecting the computer guy to be able to fix anything immediately, and that if he can't, he's an idiot. This is something else that may require some culture change among the end users.

> it's impossible to fix

This is a different problem. If he says he can't fix something, you need to show him that he can. If he exhibits any behavior other than wanting to learn more, you need to shut him down hard. IT changes constantly. Anyone who doesn't want to learn something new all the time doesn't belong in IT.

> visual basic

Eh, unless you're doing custom software development, I'd let this slide as a quirk. Everyone has a right to stupid opinions about things they know nothing about.

> where do I start?

Buy a copy of The Practice of System and Network Administration I think most folks on this sub would agree that it's a good reference for a starting (or even a seasoned) sysadmin. Read it, encourage him to read it, and use it as a starting place for the changes you want to make.

TL;DR IT guy's behavior is symptomatic of a bad relationship between users and IT. It's not all his fault. You need to take charge of the situation and bring him along. If you can't handle one frustrated sysadmin, what makes you think you can run a company?

u/Cantum2 · 13 pointsr/learnjavascript

When I was starting to learn JS which was not that long ago at all and I am still learning I started with this video series:
https://www.youtube.com/playlist?list=PLz5rnvLVJX5VdVNddvRTj68X6miAWQ5pz

.then this one
https://www.youtube.com/playlist?list=PLz1XPAFf8IxbIU78QL158l_KlN9CvH5fg&disable_polymer=true

.then this one
https://www.youtube.com/playlist?list=PL4cUxeGkcC9jAhrjtZ9U93UMIhnCc44MH

.then I read:
https://www.amazon.com/gp/product/0596517742/ref=oh_aui_detailpage_o07_s00?ie=UTF8&psc=1

.then I read: https://www.amazon.com/gp/product/1430264489/ref=oh_aui_detailpage_o06_s00?ie=UTF8&psc=1
and
https://www.amazon.com/gp/product/1118871650/ref=oh_aui_detailpage_o06_s00?ie=UTF8&psc=1

.then I read:
https://www.amazon.com/gp/product/1491904240/ref=oh_aui_detailpage_o04_s00?ie=UTF8&psc=1
and
https://www.amazon.com/gp/product/1491904240/ref=oh_aui_detailpage_o04_s00?ie=UTF8&psc=1

.then
When I felt like I had a good enough grasp on vanillajs I started a giant project in Angularjs. Where I advanced my skills with git big time. Other resources I used are:
Atom: https://www.youtube.com/playlist?list=PLYzJdSdNWNqwNWlxz7bvu-lOYR0CFWQ4I

Rest api with MEN (lol): https://www.youtube.com/playlist?list=PL4cUxeGkcC9jBcybHMTIia56aV21o2cZ8

Docs are great for js: https://developer.mozilla.org/en-US/docs/Web/JavaScript

These were good for angularjs just incase you were interested:
https://www.youtube.com/watch?v=FlUCU13dJyo&list=PL4cUxeGkcC9gsJS5QgFT2IvWIX78dV3_v

Honestly I cant link one of this guys videos because they all help sooooo much:
https://www.youtube.com/user/shiffman

u/igeligel · 13 pointsr/de

Kauf dir das Buch: https://www.amazon.de/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 oder lass es dir zu weihnachten schenken :)

Ansonsten: Wenn du schon einigermaßen was kannst guck dich mal auf github um, da gibt es zum Teil viele Projekte wo issues für Anfänger gelistet sind bei denen man relativ einfach in ein großes Projekt findet.

u/CMUKyle · 13 pointsr/Android

You're definitely going to have to have a good working knowledge of Java (or some other similarly-structured OO-language like C#). That's honestly the biggest hurdle.

For that purpose, I recommend Head First Java. It's actually a book you can read straight through (if a bit goofy), but it does a better job of teaching Java and OO concepts better than anything I've ever come across.

After that, it's pretty much developer.android.com all the way home. Best of luck!

u/drzowie · 13 pointsr/AskPhysics

Reductionism is important, but pure reductionism denies the existence of emergent phenomena (phenomena that depend on collective behavior of many simpler things). A very enjoyable book that covers this and many other topics at a popularly-accessible level is
Gödel, Escher, Bach: an Eternal Golden Braid. First published in the late 1970s, GEB is still delightfully fresh and exciting although a few minor elements are dated (e.g. computers now can beat humans at chess).

u/jalabi99 · 13 pointsr/learnprogramming

For one thing, although you may know a few languages (you mentioned Java, Visual Basic, and SQL, which isn't a language per se but you know what I mean), you may not know how to work with remote teams. You may not know how to use code versioning systems like git or SVN. You may not know how to use continuous integration software like Jenkins. You may not know how to use these and more, simply because you were never exposed to them in the course of your studies. And that's perfectly fine. You can't know everything. The problem though is that so many employers expect you to know all these things, even though you may have never even heard of them before this post.

That is exactly why /u/ResidentBiscuit said "the journey has only just begun." It's an exciting time!

I agree with what was said here:

> The Pragmatic Programmer contains 46 tips for software professionals that are simply indispensable. As the name implies, the book avoids falling into any kind of religious wars with its tips, it's simply about pragmatism.

> If you were to read only one book on this list, this is the one to read. It never goes terribly deep into anything, but it has a great breadth, covering the basics that will take a recent college-grad and transform him or her into someone employable, who can be a useful member of a team.

u/roland23 · 13 pointsr/learnprogramming

The more significant differences between CS graduates and self taught programmers are algorithm design, important coding practices, and a lot of the mathematics.

Books on coding practices exist, but vary in various corporations or programming languages.

I highly recommend MITs book on algorithm design, to some it is considered the bible of all algorithm design.

As others have mentioned, Khan Academy is a great place to start for the mathematics. Particularly CALC I, II, Linear Algebra I, II, Discrete Math I, II.

It also couldn't hurt to look into some theory of computation topics (countability, turing machines, etc.)

u/sanity · 13 pointsr/MachineLearning

I recommend this book: Clean Code

We gave it to every new data scientist we hired at my last company.

u/Heartomics · 13 pointsr/MachineLearning

It would be hard to evaluate yourself. It's probably best to link your Github work to someone and ask for their opinion.

PEP 8

The biggest hurdle is to accept that there's a Pythonic way of doing things.

I think a lot of people's first step to becoming Pythonic is by the way of using List Comprehensions.

Then there's generators, decorators, itertools, functools, collections, etc.

What it takes to be an Expert in Python

I'm sure his Python skill is amazing; I was too distracted by his VIM skill to pay attention.

These are language-specific things but it sounds as though you might want to get familiar with proper Software Engineering principles. Recognizing code smells and trade-offs between different Data Structures and Sorting Algorithms. You can start off with this excellent book on being pragmatic.

Pragmatic Programmer

Here are some youtube links where you can follow along and maybe even adopt their coding style. I don't remember if they are Pythonic or whatnot but I would guess that they are. They focus on projects you would have an interest in.

Sentdex

u/johnnydsick · 13 pointsr/csharp

I really enjoyed the C# Player's Guide. There's a newer version now but this is what I got.

Edit: I'm glad you guys liked this book as much as I did. To OP, I would offer two more suggestions.

  1. Clean Code This book is NOT specific to C#. However, it gives you a holistic understanding of how to write code that is readable and effective. This is how I was able to transition from writing code that simply functioned (primarily for school) to code that my coworkers could pick up and run with. The book is the bible of software style where I work.

  2. C# and the .NET Framework This is a very optional book in my opinion. It is also a little pricy, very long, more intermediate than beginner and you can gather much of its information from MSDN. However, I prefer looking things up and reading them in a book where possible. I also like having all this information in one location. When I have free time at work, I find myself more likely to flip to an unread section and skim over it than I would with the same information online.
u/cookenmeth · 13 pointsr/HowToHack

There’s a book called, “Hacking: The Art of Exploitation,” that includes a lot of assembly.
https://www.amazon.com/Hacking-Art-Exploitation-Jon-Erickson/dp/1593271441

u/LongUsername · 13 pointsr/compsci

I'd second unplugging completely: no computer, TV, electronics. If you insist on doing something CS related, Godel, Escher, Bach comes highly recommended.

u/Clamhead99 · 12 pointsr/learnprogramming

Yeah, you definitely should get a intro to java book and go along with it.

Perhaps check out Head First Java. It's ... a bit cheesy (cause they try to make it "fun"), but I found the material to be pretty solid for beginners.

Looks like someone uploaded it online, if you dont mind reading a textbook on a screen.

u/meathead80 · 12 pointsr/exjw

There's a reason why there is a Javascript book (1096 pages) and another called Javascript: The Good Parts (176 pages).

I think the bible could use a similar treatment.

u/veruus · 12 pointsr/linuxadmin

The Practice of System and Network Administration, Second Edition

UNIX and Linux System Administration Handbook - 4th Edition

[TCP/IP Illustrated, Volume 1: The Protocols - 2nd Edition] (http://www.amazon.com/gp/aw/d/0321336313/)

These should be part of every ops department's library, if not already in your own personal one.

u/sbsmith · 12 pointsr/gamedev

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:

  1. If you're already familiar with C++, I would highly recommend reading Effective C++ by Scott Meyers (http://www.amazon.ca/Effective-Specific-Improve-Programs-Designs/dp/0321334876). Every C++ developer should read this.

    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.

  2. I worked with Unity only briefly to prototype a game, so I can't really comment here.

  3. This is tricky. I think you will need to find a passion project in C++ so that you will just naturally learn more about the language. And speaking of passion: you need to really want the job you are applying for. I have seen qualified developers miss out on jobs because you could tell they were just looking for anything (rather than really being enthusiastic about the position).

    I hope that helps.
u/dev_bry · 12 pointsr/learnprogramming

You've already done the first step: admitting that college can only teach the fundamentals while the rest of the things you need to know, you will learn while working.

With that out of the way, here's the next step: apply the Joel Test to your new employer.

If it gets an 11 or 12, you'll be fine. Find a senior developer there to mentor you and you'll be a decent software engineer in 1 - 2 years.

Otherwise, while you might learn a lot of new stuff in your first job, they might be inadequate, outdated, or outright incorrect. In this case, plan an exit strategy ASAP so that you can leave to another company that has a much higher score in the Joel Test. In this fast paced software industry, it makes no sense to spend 5 years in a company where you'd only get to grow the same amount as another guy who just spent 6 months in a better company.

Next step: read. No, not those "Teach yourself [insert language that will be deprecated in 2 years] in 24 hours" books - find the books that teach software engineering, lessons that don't get outdated. Here's the usual suggestions:

u/MirrorLake · 12 pointsr/learnprogramming

"Code" by Charles Petzold, if anyone wants the link.

u/Daersk · 12 pointsr/computerscience

I started to teach myself C, and this book has been an unbelievable resource. It starts pretty basic, but it gets into the meat of C pretty quickly.

u/w3woody · 12 pointsr/computerscience

Read about the topic.

Practice.

Set yourself little challenges that you work on, or learn a new language/platform/environment. If you're just starting, try different easy programming challenges you find on the 'net. If you've been doing this a while, do something more sophisticated.

The challenges I've set for myself in the recent past include writing a LISP interpreter in C, building a recursive descent parser for a simple language, and implementing different algorithms I've encountered in books like Numerical Recipes and Introduction to Algorithms.

(Yes, I know; you can download libraries that do these things. But there is something to be gained by implementing quicksort in code from the description of the algorithm.)

The trick is to find interesting things and write code which implements them. Generally you won't become a great programmer just by working on the problems you find at work--most programming jobs nowadays consist of fixing code (a different skill from writing code) and involve implementing the same design patterns for the same kind of code over and over again.

----

When I have free time I cast about for interesting new things to learn. The last big task I set for myself was to learn how to write code for the new iPhone when it came out back in 2008. I had no idea that this would change the course of my career for the next 9 years.

u/BroDudeGuy · 12 pointsr/learnprogramming
u/PhantomRacer · 12 pointsr/programming

I highly recommend JavaScript: The Good Parts. I'd say to read that one first because it explains how you should think when programming in JavaScript. Knowing the syntax and function names is no good unless you how to use them.

u/Joecasta · 12 pointsr/computerscience

If you aren't doing well in your current CS courses, I'd highly recommend you focus on your university's courses and do well in them before deciding to bite off more than you can chew. Do some research and look for very basic coding books, not ones like this: https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=sr_1_1?ie=UTF8&qid=1478891766&sr=8-1&keywords=introduction+to+C+programming

Look for a bit more like this: https://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=sr_1_1?ie=UTF8&qid=1478891799&sr=8-1&keywords=Head+first+java


This depends on what language you are currently learning right now. Don't worry about entering contests and participating in projects or open source coding until maybe second or third year in especially if you haven't had any prior experience. Don't rush yourself into this, you need to make sure you absolutely understand the basics before going into things like hackathons or being very concerned about internships. Take your time learning, and don't enroll onto too many online courses if you think that you can't handle it. Yes, online courses can be helpful, and will only be really helpful if you treat them like real classes. I would advise against code academy or khan academy to learn languages since I've gone through them and they never helped me really grasp CS material better than a book and actual coding. Key here is to code as you go through a book, or else you'll never learn how to actually code. Do tons of simple programs and if you don't understand code bits, don't get frustrated. Copy paste the code, and use a debugger (a bit more advanced but very very helpful) to go through step by step what the code is doing.


Main Points:


  1. Don't rush, learn slowly, fully understand each concept before moving on


  2. This won't be very intuitive for most people, it's like learning an entirely new thing, but you will eventually hit a wall and learning gets much much easier in the future.


  3. Don't do more than one or two online courses, and don't be too concerned about doing any projects or competitions you likely won't be able to understand most project code or any, same goes for competitions until you at least fully know how to code in an industry standard high level language such as C/C++ or Java.


  4. There's a lot to do, but don't overwhelm yourself, pause every now and then and focus on a single task


    Best of luck to you, remember to enjoy the process, and keep in mind that while you might not like coding, CS isn't coding. It's the principles that underlie what we can do with code. A lot of it comes from really basic logic, you will be surprised in the future how easy some things can be to understand with basic step by step thinking.
u/frenchst · 12 pointsr/cscareerquestions

Three CS fundamental books in the order I'd suggest someone read them if they don't have a background in CS.

u/eramos · 12 pointsr/programming
u/whatiswronghere · 12 pointsr/java

I would definately recommend going for a book. Head First Java is the book I'm learning from right now, and I find it to be engaging, funny, and on point.

u/FeepingCreature · 12 pointsr/starbound

I think this is the problem:

this is what you thought you were saying:

> I think "months" is an exaggeration and I think a lot can be picked up by just reading existing docs.

this is what people thought you were saying:

> I think I know better than The Mythical Man-Month. A new programmer can jump right in at 100% without requiring any instruction or support.

this is what you were actually saying

> I don't buy that new programmers need to be taught existing code...

I mean dude, come on. Either you're backpedalling now or you suck at expressing yourself.

u/brianbrennan · 12 pointsr/webdev

I think this article is great. Writing good maintainable code is a must for those that want to advance with their career. I'd suggest Clean Code to those that want to get better at this. Note that this is not a fun book, the first chapter even goes into detail saying how it's going to be a slog to get through. Other things to do are submit code for regular review, try and work with others as much as possible since it will make you much better at programming, and take your time doing things the right way, rather than the fast way. Speed comes later.

u/Duraz0rz · 12 pointsr/learnprogramming

There's a book called Clean Code that may interest you. I have it and still need to read through it, but it's been recommended countless times on here.

u/Reptilian_Overlords · 12 pointsr/talesfromtechsupport

I'd go read books about the A+ cert (you don't need to certify but it's great material).

For other technical things I recommend a lot of books that are amazing:

u/v3nturetheworld · 12 pointsr/cscareerquestions

well depends on what you want to learn. Do you only want to do webdev stuff or learn a ton about CS concepts? I'm going to answer in terms of learning CS stuff, but first here's a page on how to go from knowing nothing to knowing a wide range and depth of CS topics: you do this, you'll be a grade A software engineer!

OK, moving on. First the basics which it sounds like you've got covered.

  1. understand basic programming concepts (conditions, loops, functions)
  2. learn a programming language pretty well, it doesn't matter what language. Being good at and Understanding CS concepts does not involve mastering a single language... once you get the concepts any language will be easy to learn... It sounds like you know some Javascript (not my personal recommendation for learning CS concepts), personally I'd recommend Python (easy syntax, great resources, wide use, etc..)

    OK, now where it sounds you stand. Learning the Advanced stuff.

  3. Algorithms: The bread and butter of programming. There are many resources out there, if you want to buy a book, the gold standard is "Intro to Algorithms, 3rd edition ". Other than that, I'd suggest just the relevant Wikipedia article for algorithms. Take the pseudocode and implement it yourself in your language of choice. Understand what the algorithm is doing. Compare it to similar algorithms, understand why/when it's better or worse.

  4. OK, now that you've got that done, you can start making more complicated stuff. Come up with some silly or interesting real world examples to practice with. I suggest at this point learning more about Object Oriented Programming... learn about Classes, class structure, generics (this all varies by language). Practice, practice, practice. 4 hours of coding a day if your not doing anything else, spend the rest researching/reading.

  5. Learn how to use Unix/Linux. it's good for you(tm)

  6. optional but cool: Learn about Computers structures and how operating systems work, bonus points if you want to build a basic OS from scratch (this requires learning a systems language like C/C++/Rust and some assembly).

    anywhoooo that's kind of an overview/recommendation... feel free to ask any more questions/clarifications/suggestions for resources.
u/Sorten · 12 pointsr/learnprogramming

I've heard this book discussed before; perhaps you would be interested in it?

http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

u/Prcrstntr · 12 pointsr/cscareerquestions
  1. Get the book Introduction to Algorithms. You can find a pdf online.

  2. Read it, and try to program and understand the simpler algorithms: Do the sorting algorithms first, and then go for the binary tree algorithms.
u/pat_trick · 12 pointsr/learnprogramming

If you want to pick up some Cryptography, The Code Book is a great intro.

Pragmatic Thinking and Learning is good for learning to learn.

The Pragmatic Programmer is good for project code planning and learning how to write code in a well thought out way.

Ethernet: The Definitive Guide is a good read if you want to get up to snuff on your networking, though it can be a bit dry at times.

u/EraZ3712 · 12 pointsr/cpp_questions

Books are still the best way to learn C++! C++ Primer, 5th Ed. covers all the basics of C++11 from functions and standard library usage to OOP and templates. Effective C++ reinforces good practices and idiomatic C++ that, despite being written for C++98, is just as relevent today as it was then, some of its contents even more so than ever before. Then Effective Modern C++ then does the same for C++11 and C++14 features, building on top of what C++ Primer covers about C++11 and introducing the subtle changes brought about by C++14. This is my primary recommendation for learning modern C++ from the ground up.

But we live in the internet age! Best make use of it! So many wonderful talks from conferences such as CppCon, C++Now, Meeting C++, ACCU and Code::Dive are all available for public viewing. With regards to modern C++, Herb Sutter's CppCon 2014 Back to the Basics! Essentials of Modern C++ Style and CppCon 2016 Leak-Freedom in C++... By Default are great videos to watch. For more specific topics, here is a list of videos that I've seen and personally found engaging, educational, and worth my time to watch (multiple times!):

  • The Exception Situation for exception handling,
  • rand() Considered Harmful and What C++ Programmers Need to Know about Header <random> for random number generation,
  • Everything You Ever Wanted to Know About Move Semantic (and then some) for move semantics (by one of the authors of the proposal that introduced it!),
  • Modern Template Metaprogramming: A Compendium for template metaprogramming,
  • Lambdas from First Principles: A Whirlwind Tour of C++ for lambda expressions (this one is very good!), and
  • Type Deduction and Why You Care for auto and decltype(auto) (I miss Scott :'( ).

    There are also shows such as CppChat and CppCast where interesting events, projects, papers, and people related to C++ are brought up and discussed. There are so many interesting blogs to read!

    And there is always people on IRC (##c++, ##c++-basic, and ##c++-general) and the Cpplang Slack Channel for live updates, discussions, debates, questions, answers, and/or just plain fun with a group of people that ranges from complete noobs who are learning the basics, to committee members and library authors whose names are known across the community. If you ever have a question or need help, these are the places to go and ask (/r/cpp_questions is nice too! :P ).

    And finally, links to videos, blog posts, articles, papers, interesting Stack Overflow questions, almost everything mentioned above is constantly being shared at isocpp.org and on /r/cpp. Subscribe to both to get a constant stream of links to anything and everything about C++.

    Edit: as for C++17 material, the standard is not technically completed/published yet, but that hasn't stopped the community from creating material about it! This paper lists all the changes from C++14 to C++17, with links to relevant papers, and this Git repo provides a simple "then, and now" comparisons of the major changes to the language. Talks describing the changes in breadth and in depth have been given at conferences, and blog posts have been written for a more textual description of the changes. C++17 is not a major update like C++11 was to C++98, but full of fixes, conveniences, more language flexibility and utility, and new toys to play with! If you have a solid foundation in C++11, C++14 and in turn C++17 should be relatively easy to pick up compared to the shift from classic (C++98) to modern C++.

    TL;DR Learn C++11 the best you can. Once you are comfortable with C++11, the transition to C++14 will feel natural, and C++17 will be waiting just around the corner.
u/wrelam · 12 pointsr/C_Programming

C Interfaces and Implementations has some decent advice for designing C programs. This is also a skill which you 'll develop with time (e.g. over your entire career) so don't worry too much about figuring it out immediately; it requires experience. As you work on various projects you'll get a sense for what works and what doesn't so that over time you'll have developed strategies for solving particular types of problems.

OOP concepts are still valid even though C may not have ways to necessarily implement them within the language proper. Object-Oriented Software Construction is a fantastic book for learning OOP concepts. As your C experience grows, you'll begin to see ways of implementing some of those design strategies with C, even though it's not an OO language.

Knowing when to use what type of data structure can also aid in simplifying your code base. The standard book for this is CLRS, but for C specific implementations and advice, see Algorithms in C.

u/Eshakez_ · 12 pointsr/ruby

Clean Code is a great resource that touches on this topic and several other coding conventions.

http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

Uncle Bob (the author of Clean Code) recommends that you organize your methods based on the context and the level of clarity. He would suggest putting the high level code near the top with the smaller helper methods near the bottom.

It compares a class to a newspaper. In a newpaper, you generally have the Subject at the top, with a high level description of the events that have taken place. As you read down the page, the articles will change from high level descriptions to low level details of the events.

Obviously, there are sometimes exceptions to this suggested rule.

TLDR: I wouldn't organize methods alphabetically. I would organize them logically from high level to low level.

u/ramblingcookiemonste · 11 pointsr/sysadmin

Sounds like you already know what you want to do! I'm on the Microsoft side of the house, love scripting, and am fortunate enough to spend the majority of my day working in PowerShell.

Definitely check out The Practice of System and Network Administration if you haven't already, it lays a great foundation for the areas in IT.

If you go the Linux / scripting route, read up on and spend more time with shell scripting and Python (perhaps Ruby if you get into config mgmt). If you go the Windows route, read up and spend more time on PowerShell. Either way, being able to code and automate will be very important in our field, it sounds like you are on the right track.

Cheers!

u/GeneralMaximus · 11 pointsr/cpp

The newest edition of C++ Primer also covers C++11. I'd recommend reading that before reading TCPPPL. See http://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113

u/chunky_bacon · 11 pointsr/programming

Head First Java. This is an outstanding, fun, book and an easy read. Good explanation of OO principles as well.

After that, just start coding. I had previously done C and Perl, but HFJ is written for the absolute beginner.

u/RenegadeDoppelganger · 11 pointsr/Design
u/faintdeception · 11 pointsr/learnprogramming

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.

u/IbeatDatPussyUp · 11 pointsr/learnprogramming

"The C programming Language" is an excellent book. I learned most of the concepts and coding from that book.

u/tagx · 11 pointsr/programming

Kernighan and Ritchie's The C Programming Language

It will teach you almost all you need to know. It is written by the creators of C and is still the best way to learn C.

I even use it as a reference for parts of C I do not use often.

Also, you should try to be running a unix os, since c programming will be much more integrated and easier.

link: http://www.amazon.com/Programming-Language-Prentice-Hall-Software/dp/0131103628

u/GoldFrame · 11 pointsr/learnprogramming

This book: https://www.amazon.com.au/Clean-Code-Robert-C-Martin/dp/0132350882.

It helped me not to feel bad when I couldn't understand somebody else's code, since it could very well be designed poorly (I was struggling for weeks at work trying to rewrite a program, my mental leap occurred when I realised I was looking at spaghetti code all along). And that coding is like an art form, it communicates an idea to the reader.

u/lbkulinski · 11 pointsr/Purdue

I recommend reading and working through The C Programming Language, which will likely be your textbook. Java syntax comes from C/C++, so that part will be somewhat familiar. C is a lot more low-level, though.

u/Professor_Red · 11 pointsr/learnprogramming

Do you already know how to program?

If not, then read Structure and Interpretation of Computer Programs.

If yes, then get C++ Primer by Lippman.

u/sitefall · 11 pointsr/learnjavascript

You're an experienced programmer: this


You're a mathematician/scientist/engineer/etc: this



You are "ok" with another language: this


You're more of a "video tutorial" learner: this (and your local library probably gives you free access, seriously check)


You're completely new to programming: this


You're 9 years old: this

u/Scott90 · 11 pointsr/cscareerquestions

I think it would be good for you to read Clean Code. The things you dismiss as unimportant are in reality super important to make for a codebase that lasts longer than a couple of months.

Good, accessible code does not contain spelling errors. A 500-line class is too long. At my work, even things like //This method does x usually get a comment saying "missing space between after //".

Yesterday, we merged in a PR that had been open for 2 days and had 76 comments on it (that, admittedly, was too much, but it goes to show that the details matter, even in large PRs). Reviewing again after incorporating code review feedback is just as important because it's brand new code that others will have to approve.

Also agree with /u/batsam that we try to keep our PRs small so it makes it easy to review.

u/nopX0f · 11 pointsr/HowToHack

Go through "Hacking: The Art of Exploitation" by Jon Erickson and learn the skills as needed. When you can make it (and I mean not just do the examples, but understand the how and why in each example) through his book you should have some good base knowledge and an idea what subjects you enjoy, pursue them in that order after that.

amazon link to book

edit formating

u/Zokleen · 11 pointsr/Denmark

Et godt sted at starte er bogen “The mythical Man-month” af Fred Brooks. https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959

IT-projektledelse er på mange måneder ikke anderledes end projektledelse generelt, men der kræves en væsentlig forståelse for, at opgaverne som oftest kan være enormt komplekse af natur.

Du vil derfor opleve, af din aller aller største hurdle ikke er dit team, som står for eksekveringen, men dine interessenter (aka stakeholder management). Uden at smøre unødigt tykt på stereotyperne, så er det de færreste “projektsponsorer” eller lign interessenter fra forretningssiden, som egentlig har bare en snært af sans for hvorfor IT/softwareudvikling er svært at tids/budget-estimere.

Et klassisk eksempel:

  • Chef: “Jamen det er jo bare en lille knap, hvor svært kan det være..!”
  • Projektleder: “Ok, trækker vejret dybt og finder whiteboard markeren frem ... lad mig forklare det igen....”
  • Chef: “ej det behøver du ikke. Jeg har allerede lovet det til kunden at vi har det klart i næste uge”


    Udfordring nummer 2 er, at din interessenter/ resten af forretningen stort ser altid lever i en “waterfall” verden, også selvom I kører agile eller lign. metoder.

    Dvs, at I som team ofte kan føle jer enormt klemt af, at den eksterne verden ikke forstår eller gider spille med indenfor jeres best practices. (Men det lyder fedt for virksomheden at proklamere “vi er agile”).

    Anyway, det skal siges at jeg til dagligt arbejder med product management, så det er lang tid siden jeg har levet i en “project-only” verden.

    Edit: typos
u/mooshoes · 11 pointsr/IWantToLearn

I'd recommend you start with the book "Code", which handles just this progression: http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

From there, investigate operating system development. The Minix OS is very well documented.

u/toastisme · 11 pointsr/IWantToLearn

A similar question was posted on Quora not long ago, and the main recommendation was Code by Charles Petzold:

http://www.amazon.co.uk/Code-Language-Computer-Hardware-Software/dp/0735611319/ref=sr_1_1?ie=UTF8&qid=1395088237&sr=8-1&keywords=code+charles+petzold

Having subsequently read the book I think it's a fantastic introduction, and goes through everything from the importance of binary code and applying Boolean logic to circuits, to the details of the inner workings of the first microprocessors, and all in an interesting and engaging way.

u/schaueho · 11 pointsr/programming

/me suggests reading Working effectively with legacy code which helps by providing more tools for proactive handling of "legacy issues".

u/MeoMix · 11 pointsr/learnprogramming

Hey man. Good to hear that you are interested in programming. :)

I don't think "books" is a good suggestions. There is a lot to read and not a lot of time in the world. Plus, programming tends to be more fun.

That being said, however, I am going to go ahead and recommend reading Code Complete. I think that book should be required reading for every programmer. You will learn a lot and it is also a fairly amusing / interesting read.

I would also like to suggest that you use StackOverflow and follow interesting conversations in it. One of the tricks to programming is to become very engrossed in it. Find things you find interesting and read/learn just for the sake of it. If you think you know language 'X' well -- go to StackOverflow, sort by votes, filter by tag and tag the language you want to read about. I guarantee you will find a lot of "Woah, I did not know language 'X' could do that."

One last thing w.r.t all the 'what languages should I learn' hullabaloo. Start a little higher level. It sounds like you want to learn an Object-Oriented language. Do you know what your other options are?

http://en.wikipedia.org/wiki/Comparison_of_programming_paradigms#Main_paradigm_approaches

There's a quick overview of the different 'types' you'd expect to see. OO is a clear one, especially for industry development, but functional languages and others may also end up being used for your job. :)

EDIT: A little more on topic. I started with C++ in school. Some concepts were difficult -- pointers, references/pass-by-reference/de-referencing, and to a lesser extent garbage collection / memory allocation.

The main argument for learning C++ first is that it gives you good fundamentals. Every programmer should know what a pointer is. And a double pointer, for that matter! The main argument against learning C++ is that you can blow your foot off much easier than in Python. And that's no fun. And if you're the type of person who isn't ...tenacious enough to try and repair your own blown off foot -- perhaps a higher-level language would be a better choice. In this way you can become more accustom to the frustrations of coding (and how to cope) before introducing more complex issues.

That isn't to say you can't create just as large a clusterfuck with Python. You can. It has its own nuances. It's just that the library support (code already written for you) is going to be more extensive. A good comparison would be driving an old car vs a new car. The engine is harder to repair in the new car (can't get at the parts), runs better, but you don't get a feel for whats in the engine. Its more of a black box. That old '57 Chevy (C++) has its engine laid bare (not as much as C), but if you're no mechanic you might break your car and abandon it.

Just do what you find fun! You're still young :)

u/entropicone · 11 pointsr/compsci

Riding on your top post coattails...

The Elements of Computing Systems and Code by Charles Petzold are exactly what you want.

Code goes through number systems, basic information theory, circuits (from gates on up), memory, machine code and programming languages, all with accessible diagrams and explanations.

TECS has you build an actual working computer from the ground up.

u/roodammy44 · 11 pointsr/cscareerquestions

I can't believe noone has mentioned The Mythical Man Month yet. If nothing else, it will help you give better time estimates for your work.

u/sh0rug0ru · 11 pointsr/programming

In Michael Feather's Working Effectively With Legacy Code, he recommends a technique of refactoring for understanding. Clean up the code as you try to understand it, extracting methods, renaming variables, etc. You don't have to commit the changes, but the act of refactoring might just foster better understanding.

u/enricopulatzo · 11 pointsr/programming

Code Complete (haven't yet read ed. 2, but the first edition was tremendous)

u/SouthernArrowwood · 11 pointsr/learnprogramming

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

u/robertwilliams · 11 pointsr/cscareerquestions

You were showing off. I probably would have hung up as well.

The best code is boring. It just reads like prose. And it's tremendously difficult to write.

I am an architect / dev lead. I read a lot of code that others wrote. I don't want to spend any brain cycles parsing your code; I need to be able to focus on what you are doing and what the overall design is.

We have one developer here who apparently gets a bonus every time he uses the ternary operator. He likes to nest them as well as AND and OR his conditions.

return cond1 && cond2 ? val1 : !cond1 && cond3 || cond2 ? val2 : val 3

Very cute, but utterly unreadable.

My advice to you is to read the following books:

u/yamamushi · 11 pointsr/cpp

I would supplement your class with one of the many great C++ books out there, because there are many ways to learn C++ but few of them are good (or even "right") ways.

You should be careful to distinguish between best practices from C++ and the new ones in C++11, and I've found that many courses tend to teach C++ as if it's just C with some extra features.

Of note, some really good books are:

u/SkepticalMartian · 11 pointsr/PHP

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.

u/iprobablydisagree · 11 pointsr/programming

You should read Clean Code.

u/jacobolus · 11 pointsr/math

Your post has too little context/content for anyone to give you particularly relevant or specific advice. You should list what you know already and what you’re trying to learn. I find it’s easiest to research a new subject when I have a concrete problem I’m trying to solve.

But anyway, I’m going to assume you studied up through single variable calculus and are reasonably motivated to put some effort in with your reading. Here are some books which you might enjoy, depending on your interests. All should be reasonably accessible (to, say, a sharp and motivated undergraduate), but they’ll all take some work:

(in no particular order)
Gödel, Escher, Bach: An Eternal Golden Braid (wikipedia)
To Mock a Mockingbird (wikipedia)
Structure in Nature is a Strategy for Design
Geometry and the Imagination
Visual Group Theory (website)
The Little Schemer (website)
Visual Complex Analysis (website)
Nonlinear Dynamics and Chaos (website)
Music, a Mathematical Offering (website)
QED
Mathematics and its History
The Nature and Growth of Modern Mathematics
Proofs from THE BOOK (wikipedia)
Concrete Mathematics (website, wikipedia)
The Symmetries of Things
Quantum Computing Since Democritus (website)
Solid Shape
On Numbers and Games (wikipedia)
Street-Fighting Mathematics (website)

But also, you’ll probably get more useful response somewhere else, e.g. /r/learnmath. (On /r/math you’re likely to attract downvotes with a question like this.)

You might enjoy:
https://www.reddit.com/r/math/comments/2mkmk0/a_compilation_of_useful_free_online_math_resources/
https://www.reddit.com/r/mathbooks/top/?sort=top&t=all

u/fazzone · 11 pointsr/programming

Meh, these sort of definitional quibbles annoy me. What is the point of manufacturing a distinction such as this that pretty much exists solely as a "gotcha"? The fundamental idea at work is that you're re-using the answers to subproblems in order to computer the answer to the big problem. As long as you've got that idea down, what's the huge philosophical difference in the order that the subproblems are computed? I'm not saying that the distinction is invalid - there is an difference for sure - just not of great importance. In fact, if I were explaining it, I'd introduce DP as a particularly clean form of memoization -- one where you have spent effort to formulate an algorithm in a way that guarantees all subproblems are solved before their solutions are required in the next tier of problems.

I'm not 100% sure, but I think I remember Introduction to Algorithms explaining it this way. They may also have gone for taxonomy where memoization is the specific mechanism of storing results of previously-solved problems and dynamic programming is the application of such to algorithms (thus there would be top-down dynamic programming and bottom-up dynamic programming).

Edit: syntax (changed "computed in" to "computed")

u/william_fontaine · 11 pointsr/cscareerquestions

Code Complete: http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

Applicable to any OO language you are using.

u/localheinz · 11 pointsr/PHP

If upgrading your application from Yii1 to Yii2 requires a rewrite, then switching to Laravel or Symfony will also require a rewrite.

If you have read Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin, then you might remember the Grand Redesign in the Sky - if not, take a look at What is Clean Code?:

> The Grand Redesign in the Sky
>
>Eventually the team rebels. They inform management that they cannot continue to develop in this odious code base. They demand a redesign. Management does not want to expend the resources on a whole new redesign of the project, but they cannot deny that productivity is terrible. Eventually they bend to the demands of the developers and authorize the grand redesign in the sky.
>
>A new tiger team is selected. Everyone wants to be on this team because it's a green-field project. They get to start over and create something truly beautiful. But only the best and brightest are chosen for the tiger team. Everyone else must continue to maintain the current system.
>
>Now the two teams are in a race. The tiger team must build a new system that does everything that the old system does. Not only that, they have to keep up with the changes that are continuously being made to the old system. Management will not replace the old system until the new system can do everything that the old system does.
>
>This race can go on for a very long time. I've seen it take 10 years. And by the time it's done, the original members of the tiger team are long gone, and the current members are demanding that the new system be redesigned because it's such a mess.
>
>If you have experienced even one small part of the story I just told, then you already know that spending time keeping your code clean is not just cost effective; it's a matter of professional survival.

Unless you and the team you work with has already asked and answered these questions, maybe there are more interesting questions to ask, for example:

  • What are the actual costs of a rewrite?
  • What is the business value of rewriting the application?
  • Perhaps the business is better off improving the current system than rewriting it entirely?
  • What can we learn about coupling our application to frameworks from this situation?
u/nutrecht · 11 pointsr/learnprogramming

> My code works, but if I was in a professional team, would they allow 5 nested if statements?

Probably not. I can strongly recommend reading the Clean Code book, it deals with a ton of these kinds of questions. And not just read it; apply what you read too.

u/hattivat · 11 pointsr/datascience

IMHO,

step 1: Read https://www.amazon.com/Pragmatic-Programmer-20th-Anniversary-2nd/dp/0135957052/ref=dp_ob_title_bk

step 2: Read https://realpython.com/python-pep8/ and https://docs.python-guide.org/dev/virtualenvs/

step 3: Write a REST API which takes arguments from the URL, uses these arguments to run some predictive model of your creation, and then returns the result; since you already know Python, I'd recommend using Flask, there are many free tutorials, just google it. If using Python, I highly recommend using PyCharm (the free community edition is enough) over Jupyter or Anaconda, the latter will let you do many bad things which would trigger a red warning in PyCharm (such us doing import in the middle of the file).

step 4 (optional, but recommended): Learn the basics of Java (this tutorial should be more than enough https://www.tutorialspoint.com/java/index.htm ) and read https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

step 5: Write a publisher application which reads a csv, xml, or json file from disk (for bonus points: from someone else's public REST API for data, for example https://developer.walmartlabs.com/docs/read/Search_API ), and turns the data contained within into a list of python dictionaries or serializable objects (btw, read up on serializing, it's important), and then sends the results into a kafka or rabbitMQ queue. I would strongly recommend sending each item/record as a separate queue message instead of sending them all as one huge message.

step 6: Learn how to use cron (for bonus points: Airflow) to make the application from step 5 automatically run every second day at 8 am

step 7: read the closest thing in existence to being the data engineering book: https://dataintensive.net/

step 8: Write a consumer application which runs 24/7 awaiting for something to appear in the queue, and when it does, it calls your rest api from step 2 using the data received from the queue, adds the returned result (predicted price, or whatever) to the data, then runs some validation / cleaning on the data, and saves it in some database (SQLite is the easiest to have running on your local computer) using an ORM (such as SQLalchemy).

step 9: Add error handling - your applications should not crash if they encounter a data-related exception (TypeError, IndexError, etc.) but instead write it to a log file (as a minimum, print it to the console) and continue running. External problems (connection to the database, for example) should trigger a retry - sleep(1) - retry cycle, and after let's say 5 retries if it's still dead, only then the application should crash.

step 10: For bonus points, add process monitoring - every time your application processes a piece of data, record what category it was in a timeseries database, such as influxdb. Install grafana and connect it to inlfuxdb to make a pretty real-time dashboard of your system in action. Whenever your application encounters a problem, record that in influxdb as well. Set grafana to send you an email alert whenever it records more than 10 errors in a minute.

Step 11: More bonus points, add caching to your application from step 2, preferably in Redis (there are libraries with helpful decorators for that, e.g. https://pythonhosted.org/Flask-Cache/ )

I'm assuming you are familiar with Spark, if not, then add that to your learning list. A recommended intro project would be to run some aggregation on a big dataset and record the results into a dedicated database table allowing for fast and easy lookup (typical batch computing task). You could also rewrite the applications from points 5 and/or 8 to use spark streaming.

I also heavily recommend learning how to use docker and kubernetes (minikube for local development), this is not only super useful professionally, but also makes it much easier to do stuff such as running spark and airflow on your home computer - downloading and running docker images is way easier than installing any of those from scratch the traditional way.

One crucial advice I can give is the mindset difference between data science and data engineering - unlike in data science, in data engineering you normally want to divide the process into as small units as possible - the ideal is to be processing just one [document / record / whatever word is appropriate to describe an atomic unit of your data] at a time. You of course process thousands of them per second, but each should be a separate full "cycle" of the system. This minimizes the impact of any crashes/problems and maximizes easy scalability¹. That is of course assuming that the aim is to do some sort of ETL, if you are running batch aggregations then that is of course not atomic.

¹ As an example, if your application from step 5 loaded all the data as one queue message, then the step 8 application would have to process it all in some giant loop, so to parallelize it you would have to get into multi-threaded programming, and trust me - you don't want that if you can avoid it (a great humorous tale on the topic http://thecodelesscode.com/case/121 ). You also have to run it all under one process, so you can't easily spread across multiple machines, and there is a risk that one error will crash the whole thing. If on the other hand you divide the data into the tiniest possible batches - just one item per message, then it's a breeze to scale it - all you need to do is to run more copies of the exact same application consuming from the same queue (queue systems support this use case very well, don't worry). Want to use all 8 CPU cores? Just run 8 instances of the consumer application. Have 3 machines sitting idle that you could use? Run a few instances of the application on each, no problem. Want the results really fast? Use serverless to run as many instances of your app as you have chunks of data and thus complete the job in an instant. One record unexpectedly had a string "it's secret!" in a float-only field and it made your app crash? No problem, you only lost that one record, the rest of your data is safe. Then you can sit back and watch your application work just fine while the colleague who decided to use multi-threading for his part is on his fifth day of overtime trying to debug it.

u/lookatmetype · 11 pointsr/AdviceAnimals

Yea, understand this book cover to cover and you'll get any silicon valley job easily.

u/Shadowsoal · 11 pointsr/compsci

In the theoretical field of complexity...

The 1979 version of Introduction to Automata Theory, Languages, and Computation by Hopcroft & Ullman is fantastic and used to be the canonical book on theoretical computer science. Unfortunately the newer versions are too dumbed down, but the old version is still worth it! These days Introduction to the Theory of Computation by Sipser is considered to be the canonical theoretical computer science text. It's also good, and a better "introduction" than H&U. That said, I prefer H&U and recommend it to anyone who's interested in more than getting through their complexity class and forgetting everything.

In the theoretical field of algorithms...

Introcution to Algorithms by Cormen, Leiserson, Rivest and Stein is dynamite, pretty much everything you need to know. Unfortunately it's a bit long winded and is not very instructive. For a more instructive take on algorithms take a look at Algorithms by Dasgupta, Papadimitriou and Vazirani.

u/Eurobob · 10 pointsr/design_critiques

This is quite the mess you've got here. I'm sorry to be so negative, but there isn't a single thing i like about this.

Your 'nav'/login section is too large, garish & out of place. Not to mention the fact that the login button shouldn't be in the nav.

The colour scheme feels like an afterthought. Everything seems so random. I don't know why your two lists are styled so differently.

Your text is too large in places and the line height is too small. Everything is very bunched up and cluttered.

The arrow on the about link is nothing short of horrific.

Going back to the text, there is no sense of hierarchy. Decide what information is most important and make sure it is clear at the top of the website. Secondary info can go below the fold if needed to keep it from looking messy.

The contact us bit again looks like an afterthought.

The logo is hideously lazy.

Overall, i don't know where to look first to find the information i'm looking for. Don't make me think!


My advice? Start again. But before you do so, have a look at some similar websites for inspiration, USE A GRID!, if you want to do a text-based design, learning the basics of typography is an absolute must.

u/doctoraw · 10 pointsr/design_critiques

I would look for a template that you think is good for his content and then adapt it. I'm not saying that you copy it, but you can inspire yourself in another's work. I'd suggest http://themeforest.net/

That said, you are not changing the design, you are changing the position of the content. You could maybe start rethinking the content tree. I would make always available the contact info. It's the best thing to do for the users and clients love to be always available ;)

You could think about the design in little pieces. For example: you have a book gallery to redesign, look for other book galleries that you like and then design stephen's.

This is my attempt. It's super simple. but I think that's what make it understandable.


http://i.imgur.com/VqwTj.png



Ask me anything you need.

I would also change the body text line-height: to 140% to make it more readable.

*edit: I would also make bigger the 'men and women' titles.

I suggest you to read Don't Make Me Think. It's a little old usability book that you could be read in half a day and will blow your mind :)

PS. Sorry for my English.

u/cabbagerat · 10 pointsr/compsci

Start with a good algorithms book like Introduction to algorithms. You'll also want a good discrete math text. Concrete Mathematics is one that I like, but there are several great alternatives. If you are learning new math, pick up The Princeton Companion To Mathematics, which is a great reference to have around if you find yourself with a gap in your knowledge. Not a seminal text in theoretical CS, but certain to expand your mind, is Purely functional data structures.

On the practice side, pick up a copy of The C programming language. Not only is K&R a classic text, and a great read, it really set the tone for the way that programming has been taught and learned ever since. I also highly recommend Elements of Programming.

Also, since you mention Papadimitriou, take a look at Logicomix.

u/Hafnium · 10 pointsr/learnprogramming
u/a_redditor · 10 pointsr/learnprogramming
u/mcrask · 10 pointsr/learnprogramming

Code Complete and Pragmatic Programmer are great books about programming as a craft and are both language agnostic.

u/SofaAssassin · 10 pointsr/cscareerquestions

> So something that would take in excess of 3 years to master is out, if you catch my drift.

You seem to be misguided on this point - while you can pick up the basics/fundamentals of programming pretty quickly, if you're so inclined, the actual practice of writing software, and writing it well, is going to take a lot of time investment. I look back at code/software I wrote when I was just starting out professionally, and while they worked, I know how poorly they compare to what I can write/design now.

Having 3 years of software development experience when starting from zero would probably leave you at 'junior' or 'mid' level at the end, and if you don't have a more experienced developer mentoring you throughout the process, you may be at a disadvantage. From the sound of it, your school has no actual programmers/developers.

With that said:

  • I would look at online resources to start out, like Learn X in Y Minutes or codecademy. Start playing around a lot and doing exercises.
  • For a beginner, a language like Python or Ruby tends to be easiest to start with, as they are simple to install and experiment with.
  • Additionally, learn about databases. MySQL and PostgreSQL are database systems that are widely used and free. Learn about database modeling, schema design, and how to actually write SQL.
  • Understand that pretty much anything you write or make in the first year or so that isn't very simple will probably be horrible hack jobs. You may not think they are, but trust me, they will probably have poor design, use nasty hacks, employ bad practices, and so forth. This is where on-going improvement is a necessity, and why people read books like Clean Code, The Pragmatic Programmer, and Code Complete.
  • Also, a mark of a good developer - assessing whether or not you have to actually write that code or software. I am not familiar with student management systems, but is it really going to be necessary to write your own, from scratch? Think of the following implications:
    • You are now your own support for your software - anyone in the school that has a problem with your app, you become the go-to person for fixing it or answering their questions, no matter how dumb the questions may be.
    • You become the point person for issues in the supporting system of the software - the database and the machines it runs on, primarily. You may be lucky enough to have IT helping you in this aspect, so hopefully you have an IT department that can do things like back up the database, maintain it, and restore it if something breaks.
    • Your software will likely be a hackjob - I do like to stress this point again, because none of us, starting out, turn out good software of moderate complexity without a couple years of experience. Time and time again I look at code written by fresh graduates or junior developers that are basically hacks or need a lot of cleanup/rewriting. Who will look over your code to tell you that?
    • Someone will have to maintain this software - and this will be you, but eventually, you might leave this job, so who will take over for you? Your school should be prepared for this eventuality.
u/remembertosmilebot · 10 pointsr/learnprogramming

Did you know Amazon will donate a portion of every purchase if you shop by going to smile.amazon.com instead? Over $50,000,000 has been raised for charity - all you need to do is change the URL!

Here are your smile-ified links:

https://smile.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

---

^^i'm ^^a ^^friendly bot

u/distantocean · 10 pointsr/exchristian

That's one of my favorite popular science books, so it's wonderful to hear you're getting so much out of it. It really is a fascinating topic, and it's sad that so many Christians close themselves off to it solely to protect their religious beliefs (though as you discovered, it's good for those religious beliefs that they do).

As a companion to the book you might enjoy the Stated Clearly series of videos, which break down evolution very simply (and they're made by an ex-Christian whose education about evolution was part of his reason for leaving the religion). You might also like Coyne's blog, though these days it's more about his personal views than it is about evolution (but some searching on the site will bring up interesting things he's written on a whole host of religious topics from Adam and Eve to "ground of being" theology). He does also have another book you might like (Faith Versus Fact: Why Science and Religion are Incompatible), though I only read part of it since I was familiar with much of it from his blog.

> If you guys have any other book recommendations along these lines, I'm all ears!

You should definitely read The Selfish Gene by Richard Dawkins, if only because it's a classic (and widely misrepresented/misunderstood). A little farther afield, one of my favorite popular science books of all time is The Language Instinct by Steven Pinker, which looks at human language as an evolved ability. Pinker's primary area of academic expertise is child language acquisition, so he's the most in his element in that book.

If you're interested in neuroscience and the brain you could read How the Mind Works (also by Pinker) or The Tell-Tale Brain by V. S. Ramachandran, both of which are wide-ranging and accessibly written. I'd also recommend Thinking, Fast and Slow by psychologist Daniel Kahneman. Evolution gets a lot of attention in ex-Christian circles, but books like these are highly underrated as antidotes to Christian indoctrination -- nothing cures magical thinking about the "soul", consciousness and so on as much as learning how the brain and the mind actually work.

If you're interested in more general/philosophical works that touch on similar themes, Douglas R. Hofstadter's Gödel, Escher, Bach made a huge impression on me (years ago). You might also like The Mind's I by Hofstadter and Daniel Dennett, which is a collection of philosophical essays along with commentaries. Books like these will get you thinking about the true mysteries of life, the universe and everything -- the kind of mysteries that have such sterile and unsatisfying "answers" within Christianity and other mythologies.

Don't worry about the past -- just be happy you're learning about all of this now. You've got plenty of life ahead of you to make up for any lost time. Have fun!

u/jmagic88 · 10 pointsr/learnprogramming
u/c_d_u_b · 10 pointsr/AskHistorians

Computer scientist here... I'm not a "real" mathematician but I do have a good bit of education and practical experience with some specific fields of like probability, information theory, statistics, logic, combinatorics, and set theory. The vast majority of mathematics, though, I'm only interested in as a hobby. I've never gone much beyond calculus in the standard track of math education, so I to enjoy reading "layman's terms" material about math. Here's some stuff I've enjoyed.

Fermat's Enigma This book covers the history of a famous problem that looks very simple, yet it took several hundred years to resolve. In so doing it gives layman's terms overviews of many mathematical concepts in a manner very similar to jfredett here. It's very readable, and for me at least, it also made the study of mathematics feel even more like an exciting search for beautiful, profound truth.

Logicomix: An Epic Search for Truth I've been told this book contains some inaccuracies, but I'm including it because I think it's such a cool idea. It's a graphic novelization (seriously, a graphic novel about a logician) of the life of Bertrand Russell, who was deeply involved in some of the last great ideas before Godel's Incompleteness Theorem came along and changed everything. This isn't as much about the math as it is about the people, but I still found it enjoyable when I read it a few years ago, and it helped spark my own interest in mathematics.

Lots of people also love Godel Escher Bach. I haven't read it yet so I can't really comment on it, but it seems to be a common element of everybody's favorite books about math.

u/bot_bot_bot · 10 pointsr/learnprogramming
u/swenty · 10 pointsr/Python

The key to building bigger systems is writing modular code. I don't mean just code made of modules, I mean code in which the module boundaries are in the right places. Code divided into the most meaningful and distinct chunks.

You want to divide areas of responsibility into separate modules, in such a way that each module has a clear, distinct and succinct area of responsibility and the interfaces between modules (the function calls and data passed) are simple and minimal. Finding the right boundaries takes thinking deeply about the problem, and considering different ways to model it. When you get it right, you will find that changing implementation of one part of the code is much less likely to cascade into other areas.

The idea that this is an important way to think about designing a program is called the separation of concerns principle.

Patterns that can help with this include dependency injection which is often required for unit testing, and which forces you to separate modules and aspect oriented programming which deals with modularizing cross-cutting concerns, things like caching, logging and error handling which often show up in many different places in your code and undermine modularity.

Code Complete by Steve McConnell addresses these issues and has lots of helpful advice for dealing with large projects and large systems.

u/PoorlyShavedApe · 10 pointsr/sysadmin

Grab a copy of the Practice of system and network Administration as a basis to start from. Not a textbook, but covers a wide range of topics and key concepts that are not tied to a specific technology stack.

u/cmyers84 · 10 pointsr/sysadmin

>However with servers, and everything else in the data center, I'm scared to do anything to them, because of fear of crashing the system.

This is actually a healthy and normal attitude to have, frankly. If you make a mistake, you aren't just interrupting one person's workday but potentially everyone's. I would use a very conservative approach to handling the servers and double check everything you want to do. Understand the potential benefits and drawbacks to your choices and actions before implementing them. This should become second nature to you during your new career.

But don't worry about breaking things. Worry about what you should do if you break things. Always have a plan in place.

I'd recommend reading a book like The Practice of System and Network Administration to get a general overview of what a system administration should look at and how one should approach the job.

u/MuseHill · 10 pointsr/gamemaker

If you haven't read it, I recommend Code Complete. It's a classic for a reason.

You read code far more than you write it, so do whatever you think is necessary to make the code more readable. You seem to be beyond the basics (self-documenting code, etc), so a few advanced tips:

  • Within a script, you can open up additional tabs that let you write more scripts so that they're all bundled together under one script name. You can use this to break a complex script down into smaller and smaller sub scripts without cluttering up your resource tree.

  • Abolish "magic numbers." In your example, if there's a number that you use that could potentially change, make it a macro (constant), enum, or global variable with a descriptive name. Macros and enums are substituted at compile time, so they don't have any "look-up" overhead during run-time.

  • I think you've already discovered why a lot of developers use scripts as often as possible: because it's easier to find and fix them than delving into an object's various events (or a room's creation code). Other than drawing, I usually have an event call a script, and the scripts are named hierarchically, e.g. sc_Creature_player_move

    There are a lot of good practices such as encapsulation, information hiding, and idempotence, that are too in-depth to get into here. IMO, GameMaker makes it really hard to follow some of these good practices, so I hope these suggestions are helpful to you.
u/EngineerBill · 10 pointsr/pebble

> 3) is it hard to program your own apps? I know a bit
> about programming (limited experience in college).
> Would I be able to pick it up easily?

Don't see anyone answering this part of your question so I'll take a shot at it:

The Pebble is programmed in C, which is not the simplest language to learn, but it's certainly doable and once you master it you'll be in awe of what it can do. It's the programming language of choice for small footprint embedded systems, so you'll find this a useful skill in the long run, even if it's just to understand what others have to do to make your app a reality.

If you've never programmed in C it's probably best to get a book and start reading. I started with Kernighan & Ritchie's The C Programming Language -> and still feel it's the Bible from which all others are derived. Of course, if you under 25 and don't know what a book is, you can always hike off to the Google and start searching "C tutorial").

Pebble Central will provides you with an SDK with all the libraries you need to access Pebble features (e.g. User Interface, timers, comm to/from the watch, etc) but to make this work you'll also need a dev environment to hook all this up to your code.

The traditional/"hard" way to code for Pebble is to set up the Pebble dev environment on your computer and use command line tools to edit/build your app. For this you'll need a copy of the Pebble SDK and a Linux/MacOS machine Inexplicably, Pebble development is not currently supported under Windows, although if you're a real keener you can set up a virtual machine, install Linux and fake it. If you want to go this route, Google "Pebble Vagrant development" and click on the first link okay, if you're really lazy you can click here ->.

Note: I've tried the Vagrant/VirtualBox VM route - trust me, it's currently so poorly documented as to be a true pain in the ass. Not recommended if you can avoid it...

Which brings us to the other alternative. Katharine Berry, an MIT student who apparently dabbles in things Pebble in her spare time, has produced the site Cloudpebble.net ->. This is a fully integrated IDE, with GitHub support and built in SDK. This really does simplify the task of building Pebble Apps, although at the expense of some privacy, as your code lives on somebody else's server. This is no problem if you're developing open source apps or simply teaching yourself but would probably be an issue for commercial developers. Still, I can attest to how much easier it makes things if you're primary focus is on getting your first app done. I love it and recommend it highly.

Whichever approach you take, you'll find the Pebble Central developer site a useful place to hang out. It's got the online docs, links off to developer forums and more. [Pebble Developer Central is located here ->] (http://developer.getpebble.com/).

There are a few examples of programs out there you can use as tutorials and/or starting point for your own designs. I found Katharine Berry's peapod App (a music control app for iOS) to be a good starting point and her httpebble App is the definitive tool for accessing web resources. Her GitHub home is here

I've also written a couple of Pebble Apps and turned them lose under the MIT License (free for reuse if attribution is preserved). My Tempus Fugit App was (I believe) the first to provide multitasking capability, as well as stopwatch, timer a "meeting cost calculator" and multiple watchfaces all in a single app. Source code for this is available here I made an effort to comment the code to help folks figure out what's going on, so hopefully this will help you get started with your own app.

So that's a quick tour of what it takes to get started. Please feel free to post follow-up questions and I'll do what I can to fill in the missing bits...


u/crccci · 10 pointsr/computertechs

Pick up a copy of The Practice of System and Network Administration. It's a great starting point for overall support and admin methodologies.

u/kotojo · 10 pointsr/IAmA

I'm just two months into my first real job for programming and have a few books I've been going through.

Clean Code is a book not just about writing code, but good code that is easily maintained and passed down to other people to understand.

Working Effectively with Legacy Code was a great read coming into company that has been around for 20 years and is on the third iteration of their product.

I am doing web development so You don't know JS, Javascript: the good parts and then Javascript The Definitive Guide have all been a great help.

If you aren't much a book person, Pluralsight.com is awesome for info on tons of different technologies and is well worth the monthly cost. Go follow every major name in your preferred technologies on twitter. They will tweet all sorts of cool things to learn about. Also, PODCASTS!!!. I don't even listen to music anymore. If I'm in the car alone I'll be listening to Dot Net Rocks or Javascript Jabber.

Lastly, there are subreddits for every tech imaginable. Go subscribe to them and hit everyone up for where they get all their info!

u/kqr · 10 pointsr/learnprogramming

If you are willing to sacrifice the "language" requirement, you could go for something like Introduction to Algorithms which will definitely make you a better programmer, regardless of your field. It contains, directly or indirectly, the solutions to 95% of the problems you'll encounter, and gives you the tools to deal with the last 5%.

u/gorset · 10 pointsr/programming

Ok, let's see. A few quick points:

Rooted in in standard, everyday mathematical notation? public static final volatile interface abstract class transient inner class inner anonymous class objects values boxed values..... etc...

Java Generics has drawn heavily from the functional programming camp which is based on lambda calculus. See google tech talk: Faith, Evolution, and Programming Languages

Extremely easy to read and understand? Go read Java Puzzlers and Effective Java to see how many easy mistakes you can make.

Static types enables blablabla...? Not possible without static typing...? Does he realize that tools like Eclipse grew out of a smalltalk project and that smalltalk pioneered automatic refactoring ages ago? Smalltalk is one of the most dynamic language around, and it's more than 30 years old.

Most bugs are found at development time with java? That's not my experience :-)

Simple puzzle: for which values for someInt does this code fail?
int myPositiveInt = Math.abs(someInt);
assert myPositiveInt >= 0;

u/auctorel · 10 pointsr/csharp

An alternative to the gang of 4 book which is easier to digest is the head first guide

Head First Design Patterns https://www.amazon.co.uk/dp/0596007124/ref=cm_sw_r_cp_apa_i_jGIzDb57C3ACR

u/javelinRL · 10 pointsr/Python

I suggest this book, Code Complete. It has nothing to do with Python and it's pretty old at this point but by reading it, I know for a fact that it has a lot of the same ideals. knowledge, values and tips that my college teachers tried very hard to impose upon me in what is considered one of the best IT college courses in my country https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

You can also procure your HR department (or your boss) and share the situation. Tell them you'd like to enroll in some courses to get up-to-speed with everyone else around you, since you don't have the same training as them. Most companies (or at least a lot of them) will offer to pay the entire thing for you too.

u/karptonite · 10 pointsr/laravel

I don't think Laravel is the right direction to be going, honestly. Laravel is great for starting new projects, but it isn't so great if you want it to be just a small part of a larger site.

I suggest you check out the following two books:

Working Effectively with Legacy Code

Modernizing Legacy Applications In PHP

I've read the first one, and can definitely recommend it. The second I haven't read, but it sounds like it may actually be more appropriate to your actual situation, since the first book often assumed that your starting code base is better than what you seem to have.

u/Karzka · 10 pointsr/gamedev

Not game-specific, but these books are definitely industry essential books when it comes to anything related to software development.

In no particular order (though Code Complete should probably be first):

u/sanedave · 10 pointsr/learnprogramming

Three books I have been using:

The Definitive Guide to How Computers Do Math

Web page here: http://www.diycalculator.com/

Assembly Language Step-by-Step: Programming with Linux

Hacking: The Art of Exploitation, 2nd Edition

The first uses a virtual machine running on Windows, with 5 registers, 65K of virtual memory, a debugger, and will give you a good basic understanding of what is going on. The second book uses Intel X86 on Linux, and gives a solid foundation of the most used instructions. The third book is just good.

Other favorites of mine include "The Art of Debugging" by Norm Matloff (google for his excellent web page) and "Professional Assembly Language" by Richard Blum.

Have fun!

u/bsmartt · 10 pointsr/compsci

I haven't heard of any of these. Unless you're pressed for time, read one of the classic DS&A books, and then read some c++ stuff. There are lots of ds&a books that are partially or fully language agnostic, they only have code blocks in pseudocode. This provides a very important opportunity for you to implement stuff in whatever language you like. Here's the one I used in college: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=zg_bs_132570011_2

u/ThomasMarkov · 10 pointsr/math

Gödel, Escher, Bach: An Eternal Golden Braid by Douglas R. Hofstadter is perhaps the most thought provoking book I have ever read. It unifies music, art, and mathematics and will simply blow your mind.

u/patrickeverett · 10 pointsr/Radiology

I recommend you become familiar with the following terms:

Rules, Regulations and Guidelines; ACR guidelines, NRDR (e.g. Lung Cancer Screening), AAPM TG-18, HIPAA 1996, HITECH 2009, MACRA 2015, PAMA 2014 (especially AUC aka CDS), PQRS, etc.

IHE (actor, transaction, profile)

DICOM (entity-relationship, GSDF, GSPS, IOD, DICOM service, SOP Class, RESTful services e.g. WADO)

HL7 (message, message type, segment, field, component, FHIR)

Image pixel data (bit, byte, bit depth, grayscale, histogram, pixel, voxel) and Image Processing (Gaussian, Laplacian, Sobel, etc.)

Speech Recognition (aka Voice Recognition), DICOM Structured Reports


High Availability and High Performance (Business Continuity, Disaster Recovery, Fault Tolerance, Failover / Failback, hot / warm / cold spare, Geographic redundancy, clustering and mirroring, RAID (RAID 0, RAID 1, RAID 5, RAID 6, RAID 50, etc.)), virtualization, iops

Networking (Packet Switching, OSI Model, TCP/IP, "Well Known Ports" - Network Protocols (DNS, DHCP, FTP, FTPS, HTTP, HTTPS, SNMP, telnet, ping, traceroute, netBIOS, netstat, ipconfig), DSL, ISDN, T-1, T-2, T-3, DS-1, DS-2, DS-3)

Encoding, Encryption and Compression (SSL, TLS, RSA, Run Length Encoding, Big Endian, Little Endian, JPEG, JPEG2000)

Nomenclature and medical coding (RadLex, LOINC, SNOMED, CPT, ICD)

Information technology Management (ITIL, ITSM, SaaS, SLA, SOA, QoS)




https://www.abii.org/About-PACS-Administrator.aspx

https://www.abii.org/docs/Certification-Guide.pdf

http://siim.org

http://siim.org/?page=ciip_study_resources

http://siim.org/?page=pii_textbook

http://www.otechimg.com

http://ihe.net

http://ihe.net/Resources/upload/ihe_radiology_users_handbook_2005edition.pdf

http://medical.nema.org/standard.html

http://www.hl7.org/implement/standards/index.cfm?ref=nav

http://www.hhs.gov/ocr/privacy/hipaa/administrative/privacyrule/index.html

http://www.hhs.gov/ocr/privacy/hipaa/administrative/securityrule/index.html

http://www.hhs.gov/ocr/privacy/hipaa/administrative/enforcementrule/hitechenforcementifr.html

http://www.fda.gov/Radiation-EmittingProducts/MammographyQualityStandardsActandProgram/default.htm

http://www.acr.org/~/media/AF1480B0F95842E7B163F09F1CE00977.pdf

http://www.acr.org/~/media/3E08C87AD6E6498D9E19769E5E5E390D.pdf


http://deckard.mc.duke.edu/pdf/Samei-TG18.pdf

http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668

http://www.pmi.org

u/tmakaro · 10 pointsr/physicsgifs

In my experience, most physicists write spaghetti code with no documentation that is a nightmare for others to work with, and even the original author of the code after not looking at it for a while.

While I don't think my code is that bad, I do think that I could have structured it to have fewer global variables by making better use of functions.

Here is a few quick tips for jupyter notebooks specifically. Here is a book on writing clean code. I would also recommend reading the python style guide (pep8 and pep257). I'd also highly recommend learning how to use a linter such as pycodestyle or pylint.

u/sweml · 10 pointsr/compsci

Clean Code: A Handbook of Agile Software Craftsmanship it explains how to write elegant code in a simple and clear manner

u/beardog108 · 10 pointsr/hacking

One thing good to learn is social engineering, as its one of the most common threats faced by basically everyone. If you learn how malicious social engineers think (and how they combine knowledge with tech based hacking), you can defend against them better. I enjoyed Unmasking the Social Engineer.

Also, if you're not experienced with low level systems, you should read The Art of Exploitation.

u/Monguce · 10 pointsr/askscience

This is a really great book about the topic. It's much simpler than you might think but kind of tricky to explain unless you know a bit of back ground. The book costs less than a tenner and will give you a while different appreciation of how computers work. Well worth a read even if it starts out seeing rather simple.

https://www.amazon.co.uk/Code-Language-Computer-Hardware-Software/dp/0735611319

u/Medicalizawhat · 10 pointsr/learnprogramming

Well I left school in 10th grade, travelled around and worked odd jobs for most of my 20's until one day while working a particularly shitty job I realized if I didn't make a change soon I'd be doing jobs like that for the rest of my life! So I went to university and studied something unrelated for a few years. Somewhere along the line I clicked a link on Reddit that said "Try Ruby!" and it took me to a site kindof like Code Academy with a tutorial for Ruby. I tried it out, got instantly hooked and started spending all my free time programming!

Eventually it got to the point where programming all the time made me fail a few units so I dropped out of uni. I enrolled in a programming course but that didn't work out either, so I decided to take six months and just teach myself programming full time. It was a really awesome time, I'd wake up every morning and work on my projects, take online courses and read programming books all day!

Eventually I started running out of money. I didn't think I was good enough yet but the fact that I was rapidly becoming destitute gave me the kick I needed to start applying for jobs. I was incredibly lucky in the fact that I ended up getting hired at the first place I applied. Apparently they chose me over the other candidates because of my "life experience" and the projects on my Github, although the fact that I was willing to work for peanuts helped as well haha.

That was over six months ago and I'm still really enjoying it. If I were to offer some advice it would be to just stick with it. Even when you doubt that you are good enough, or smart enough, or that this whole learn programming idea might not work out at all and you'll never get a job - keep at it! If you enjoy programming and put the effort in then someone, somewhere will give you a chance, and all you need is one chance.

Also, make sure to take projects through to completion and post them on your Github. One simple, well written project is more valuable then 20 half finished ones. Code your projects knowing that your future employer will be reading it and deciding whether or not to hire you!

To that end, I'd highly recommend Clean Code. This book really helped me, but I'd recommend reading it after you've written a project of your own. Then, as you read through the book, go through and refactor your code.

Finally, when you're thinking of projects, don't worry about trying to create something amazing straight off the bat. Pick anything that interests you, maybe scratch an itch, or even re-implement something that already exists. At the end of the day the idea does't matter as much as the fact that you've spent the time and effort to build something. If you look at my projects, they're boring as anything! But they were good enough to get my foot in the door.

All the best!

u/Grazfather · 10 pointsr/engineering

Anyone who likes this stuff should really read code. The author goes from tin-can phones to building a computer, in language anyone could follow.

u/Gr8ingPresence · 10 pointsr/compsci

I don't think it's reasonable to speak about "canon" books in computer science - the field has become so broad that a handful of PhDs in the modern era could get to the very bleeding edge of their niche and not share any crucial books in common among their libraries.

That said, here are a few I think are fantastic:

u/JackBeePee · 10 pointsr/learnprogramming

http://www.amazon.com/dp/0321714113/ C++ Primer is what I bought and I found it very useful. It covers all the c++11 stuff

u/mcscottmc · 9 pointsr/compsci

https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319/ref=mp_s_a_1_1

This book explains how computers work from first principles (electricity and switches on up). Very easy to read. I am surprised it hasn’t been mentioned yet.

u/tasulife · 9 pointsr/arduino

Learning electronics is a lot like music. There is an insane amount of information, but if you get an economic working knowledge under your belt, you can really do some amazing things. In order for you not to get lost in the rabbit hole, I will provide you these methods of learning practical hobby electronics.

First, is simply just a suggestion. There are two "domains" of electronic thinking and analysis: digital and analogue. Fuck analog right in its dumb face. The math used in analog is fucking super duper hard, and analog circuits are prone to interference problems. Digital is where you want to be. It's vastly simpler to use programmable digital parts, and analyze digital circuits. Don't get lost in AC equations of capacitor, or the god damned transistor equation (seriously, fuck that. )

Okay here is how I learned hobby digital electronics:
First buy this, and go through all the examples in the workbooks. When you learn electronics you 100% HAVE TO DO HANDS ON LEARNING! DONT LEARN IT FROM A BOOK! MAKE CIRCUITS!
https://www.amazon.com/Radio-Shack-Electronics-Learning-20-055/dp/B00GYYEL8I

At the same time, read this (which is a good topical explanation, and free):
http://jacquesricher.com/NEETS/

And buy and read this (which is an EXCELLENT formal introduction into the physics):
https://www.amazon.com/Practical-Electronics-Inventors-Third-Scherz/dp/0071771336

Also you are going to learn how to program, which is an entirely different topic. Programming and hobby electronics make you a master of the universe, so it's worth it. I learned programming in the electronics domain and it was awesome. I made a microcontroller FM synthesizer:
https://www.youtube.com/watch?v=3TvuzTK3Dzk

So basically, the way I learned programming in general was self-teaching with books. Again, you have to do it hands-on. Actually complete the examples in the books, and you'll be fine.
First, learn procedural c programming using C primer plus. Buy an older version so it'll be super cheap:
https://www.amazon.com/gp/offer-listing/0672326965/ref=sr_1_3_twi_pap_1_olp?s=books&ie=UTF8&qid=1465827790&sr=1-3&keywords=c+primer+plus

Next, learn Object oriented programming using head first java. They do a great job of tackling OOP, which can be a difficult thing to learn.
https://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=sr_1_1?s=books&ie=UTF8&qid=1465827860&sr=1-1&keywords=head+first+java


You're overwhelmed because they're deep topics. But, seriously, its the most fun shit ever. You'll love learning how to do it.


u/RussJancewicz · 9 pointsr/linux

People might argue that you really don't need to learn C. They are lying to you. Go buy this read it over the summer, it will do nothing but help you with anything else you ever decide to code in even if you never touch C again.

http://www.amazon.com/C-Programming-Language-2nd-Edition/dp/0131103628

u/gavlois1 · 9 pointsr/FreeCodeCamp

It depends on how much programming experience you have. If FreeCodeCamp is all you've done and have only worked with JavaScript, then I think that CS50 would be worth going through. For the first few lectures, he goes material which uses C and talks about low-level memory management and how many things work under the hood. While this isn't necessary to the daily work of a web developer, it is still good to write code while being conscious of what's happening under the hood through all those abstractions.

As /u/artotal said in his reply, learning the fundamentals of data structures and basic algorithms and complexity really go a long way. I don't think CS50 goes very in-depth with regards to this, but there's a few different sources you could learn from. You could go the hands-on route and hop straight onto sites like HackerRank and Kattis and start working your way up the problem ladders if you already have some basic familiarity. If learning from scratch, FreeCodeCamp has a nice set of videos on their YouTube channel talking about different data structures implemented in JS.

As for general progression after FreeCodeCamp, keep building projects. I'm not sure how far you're into the curriculum, but it's quite long and it's got many projects even in the curriculum if you do both front and back end curriculums. With your currently existing projects, go back and see if you can make improvements to any of them. Maybe try and move them off of Codepen (if you did them there) and to your own personal portfolio site. Refine your portfolio page and have links to your projects, your Github, resume, etc. You can have free hosting through Github Pages and you should be able to host all the front end projects there. For Node projects, you can try hosting them through Heroku, or see about free hosting through Google Cloud or get trial credits on AWS or Digital Ocean.

I hope this gave you a general idea of how to progress. Choose what you want to do depending on your immediate goal. Looking for a job? Polish that resume, get your portfolio site and projects up and running, maybe get a domain name for it. Go on HackerRank and LeetCode and practice some common interview problems. Have a bit of free learning time? Dive into the fundamentals of CS. Consider taking a look at some of the tried and true CS textbooks like this one (I'm sure that with some Googling you can find links to a pdf of it for free).

u/flatlandinpunk17 · 9 pointsr/sysadmin

Read this and make a task and project list

Aside from that I work at an MSP and quite enjoy my workload but no 2 days are the same.

u/SharmaK · 9 pointsr/books

For some physics :
Penrose - Road to Reality

Gleick - Chaos

Some math/philosophy :
Hofstadter - Godel, Escher, Bach: An Eternal Golden Braid

Anything early by Dawkins if you want to avoid the atheist stuff though his latest is good too.

Anything by Robert Wright for the evolution of human morality.

Pinker for language and the Mind.

Matt Ridley for more biology.

u/dhobsd · 9 pointsr/askscience

Hooray, a question I can answer!

One of the problems here is that the question is worded backwards. Binary doesn't combine to give us programming languages. So the answer to your question is somewhat to the contrary: programming languages were invented to ease the tedium of interfacing using binary codes. (Though it was still arguably tedious to work on e.g. punched cards.) Early interfaces to programming machines in binary took the form of "front panels" with switches, where a user would program one or several instructions at a time (depending on the complexity of the machine and the front panel interface), using the switches to signify the actual binary representation for the processor functions they desired to write.

Understanding how this works requires a deeper understanding of processors and computer design. I will only give a very high level overview of this (and others have discussed it briefly), but you can find a much more layperson accessible explanation in the wonderful book Code: The Hidden Language of Hardware and Software. This book explains Boolean logic, logic gates, arithmetic logic units (ALUs) and more, in a very accessible way.

Basically, logic gates can be combined in a number of ways to create different "components" of a computer, but in the field of programming languages, we're really talking about the CPU, which allows us to run code to interface with the other components in the system. Each implementation of a processor has a different set of instructions, known as its machine code. This code, at its most basic level, is a series of "on" or "off" electrical events (in reality, it is not "on" and "off" but high and low voltages). Thus, different combinations of voltages instruct a CPU to do different things, depending on its implementation. This is why some of the earliest computers had switch-interfaces on the front panel: you were directly controlling the flow of electricity into memory, and then telling the processor to start executing those codes by "reading" from the memory.

It's not hard to see how programming like this would be tedious. One could easily write a book to configure a machine to solve a simple problem, and someone reading that book could easily input the code improperly.

So eventually as interfacing with the machine became easier, we got other ways of programming them. What is commonly referred to as "assembly language" or "assembler" is a processor-specific language that contains mnemonics for every binary sequence the processor can execute. In an assembly language, there is a 1:1 correlation between what is coded, and what the processor actually executes. This was far easier than programming with flip-switches (or even by writing the binary code by hand), because it is much easier for a human to remember mnemonics and word-like constructs than it is to associate numbers with these concepts.

Still, programming in assembly languages can be difficult. You have to know a lot about the processor. You need to know what side-effects a particular instruction has. You don't have easy access to constructs like loops. You can't easily work with complex datatypes that are simply explained in other languages -- you are working directly with the processor and the attached memory. So other languages have been invented to make this easier. One of the most famous of these languages, a language called "C," presents a very small core language -- so it is relatively easy to learn -- but allows you to express concepts that are quite tedious to express in assembler. As time has gone on, computers have obviously become much faster, and we've created and embraced many languages that further and further abstract any knowledge about the hardware they are running on. Indeed, many modern languages are not compiled to machine code, but instead are interpreted by a compiled binary.

The trend here tends to be making it easier for people to come into the field and get things done fast. Early programming was hard, tedious. Programming today can be very simple, fun and rewarding. But these languages didn't spring out of binary code: they were developed specifically to avoid it.

TL;DR: People keep inventing programming languages because they think programming certain things in other ones is too hard.

u/Nergalwaja · 9 pointsr/learnprogramming

As someone who also has been looking to delve deeper into C for a better understanding of the language and programming in general, I would recommend The C Programming Language, 2nd Edition by Kernighan and Ritchie.

https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628

While it's not a huge tome of a book, the amount of material and exercises is invaluable, and I've learned more in the first 15-20 pages than I've learned googling or from other resources in the last several months. For 35 bucks new, this book is worth it, although it's even cheaper if you rent or buy it used.

u/nsfwelchesgrapejuice · 9 pointsr/cscareerquestions

If you already have an engineering degree then you already know how to study. What experience do you have with embedded? If you don't have any then you should be sure it's what you want before you commit to anything huge.

I think the best way to get a job in embedded systems is to build embedded systems, and not bother with language certifcations. I might be going against the grain here a bit but I would suggest starting to dip your toes into embedded systems by buying an arduino and messing around with it.

Arduino gets a lot of flack for being "not real" embedded systems, and while it's true nobody is going to hire you because you can make an impressive arduino project, IMHO it's a great introduction to what embedded is about. The hardware equivalent of "hello world" is blinking an LED. If you are serious about learning then you will quickly outgrow the arduino, but you can always throw away the bootloader and try to program the ATmega with bare metal gcc and avrdude.

I don't know what you already know nor how you feel about math, but things you will want to learn include:

  • Analog electrical theory, DC and AC, resistance/capacitance/inductance. Understand basic circuit networks and input vs output impedance. Hopefully you remember complex numbers and frequency response. You don't need a lot of circuit theory but you will need to understand what a pull-up resistor is and why it's necessary. Depending on your math background you can get into filters, frequency response, fourier analysis. A good introduction here might be www.allaboutcircuits.com

  • Digital theory, starting with boolean algebra, logic gates, adders/multiplexers/flip-flops, all the way up to computer architecture. I like this book because it has a very holistic approach to this area https://www.amazon.com/Digital-Design-Computer-Architecture-Second/dp/0123944244/ref=sr_1_1?ie=UTF8&qid=1494262358&sr=8-1&keywords=harris+digital+design

  • Linux, C. Linux and C. You need to understand pointers, and the best way to understand C is to understand computer architecture. If you're not already running Linux, install linux, as well as gcc and build-essential. Start learning how to manipulate memory with C. Learning about computer architecture will help here. My favourite book on C is one of the classics: https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=sr_1_1?ie=UTF8&qid=1494262721&sr=8-1&keywords=the+c+programming+language

    If you get this far and still want to become an embedded systems engineer then you're doing pretty well. I would say just try to build projects that utilize these skills. Maybe you can use your mech background to build a robot and then design the software to support it. Get used to reading datasheets for parts, and imagining what the digital logic inside looks like. Get used to searching google for answers to your questions.
u/Newt_Hoenikker · 9 pointsr/C_Programming

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.

  • How are you with Data Structures? Algorithms? Which are you familiar with? How extensively have you used them? CLRS is a decent starting point with pretty broad coverage and good descriptions.

  • What about Design Patterns? Which ones? How much? They're not so much applicable in C, but C++ and other OOP languages are lousy with them. My university was way too into this book, but it wasn't bad; bonus all the examples are in C++.

  • How portable is your code, generally? What's your programming environment like? Windows? Mac? Linux? *BSD? Games are usually Windows oriented, but there's a lot that C/++ can do aside from that, and IMHO the best way to learn systems programming is with C and a Unix-like OS.

  • What is it exactly that you want to accomplish with your code? A broader engine? A more portable engine? Something not game related? In my experience learning for the sake of learning is great and all, but I lack drive without a concrete goal I'm working toward.

    Hope this helps.
u/AladdinP · 9 pointsr/C_Programming

C is good to learn as a beginner, although it is an unforgiving language. If you can write C, you will be able to learn the vast majority of other programming languages in common use today with a very small learning curve.

Any CS department worth anything is going to have you write in low level languages at some point, especially C and assembly.

To get started, you're going to need a good C compiler - I recommend GCC. The C Programming Language is also a priceless resource for anybody interested in learning C. Finally, although this is optional, you should learn to use a "serious" text editor, such as emacs or vim.

u/bonesingyre · 9 pointsr/compsci

Introduction to Algorithms, 3rd Edition

Surprised no one mentioned this one. This book goes into more depth on the topic, including theory and derivations of formulas.

Its definitely one of the best Algorithm books out there.

I would also look into Coursera, specifically Stanford's algorithm design class, it uses the above textbook and goes into more of the design of algorithms vs. here is how they work.

u/0b_101010 · 9 pointsr/learnprogramming

Hi! I recommend the following books:

u/metahGVA · 9 pointsr/learnprogramming

Introduction to Algorithms is probably the best book if you want to go deep in algorithms eventually.

Cracking the coding interview book is also a great repository of "must-have" concepts for CS.

u/IamAlbertHofmann · 9 pointsr/learnprogramming

here you go

It's the 'hidden language', not 'secret'. Sorry about that.

u/1000Parsecs · 9 pointsr/gamedev

If you've never programmed anything before and you really want to learn coding (if it's your priority) instead of rushing out your first game, I think LÖVE is pretty great for that. You get to learn Lua and an awesome framework. There's also Phaser, which you can learn JavaScript or its variants with it. JavaScript is probably more widely used than Lua because of the World Wide Web.

And when you're done with those, you can try to learn Java and use libGDX, or C# and Unity.

GameFromScratch.com has plenty of tutorials to get you started.

When you've decided you want to be an ultra low-level programmer, buy The C Programming Language. Learn the basics of C, and then follow Handmade Hero.

When you're done with that you're probably on your way to become a godly programmer. You'll probably know how to do some assembly and machine code by then.

But first, you're gonna need lots of discipline to even get to anywhere.

There are no shortcuts.

If you just want to make a game, however, GameMaker and Construct 2 are pretty awesome!

u/ssimunic · 9 pointsr/learnprogramming

Yes, there is also Head First Design Patterns which is also very good.

u/spoon16 · 9 pointsr/java

Clean Code http://amzn.com/0132350882

Code Complete 2 http://amzn.com/0735619670


Both are great books. I just finished reading Clean Code and I highly recommend it.

u/NotAGeologist · 9 pointsr/computerscience
u/sleepingsquirrel · 9 pointsr/ECE
u/DR_Nova_Kane · 9 pointsr/sysadmin

This is by far my favorite book. I liked it so much I have the first and second edition.

http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668

u/kabbotta · 9 pointsr/cpp

If you already know the basics of programming, then the C++ Primer is also an excellent introduction. The 5th edition is updated to include C++11.

u/weasler · 9 pointsr/compsci

Code is an absolute classic.

u/cajun_super_coder2 · 9 pointsr/csharp

One of the best ways to learn is by studying other people's code. Using book references like the one you have on C# is a great start. Make sure you ask questions to yourself and really study the code. Questions to keep in mind: why is this line before that line? What would happen if these two lines were swapped? How could I make this easier to read? Do all of these lines make sense when grouped together in a function? How can I break this down into a simpler class/object?

Those are the kinds of questions professional developers ask themselves on a daily basis. If you start asking yourself those kinds of questions early, you'll become a very competent programmer.

I highly recommend new programmers to read Code Complete: http://www.amazon.com/dp/0735619670/ref=cm_sw_r_tw_awdm_ZlAbvb1GP04MC

The fact that you've submitted this question indicates that you're on the right track. You just need practice.

u/jonconley · 9 pointsr/sysadmin

When I have time to pick new projects, I just pick up the bible and start reading until I have my next project.

  • Get everything in an asset management system.

  • Get everything monitored, logging, notification, etc.

  • Track ticket metric to see where users are having the most issues and/or delay.

  • Create a list of everything I want to automate.

  • Create a list of everything we could be doing proactively.

  • Create a list of every single point of failure and possible solutions.


u/ActionHotdog · 9 pointsr/cscareerquestions

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:

  • Design patterns! There's so many and while a lot of them are pretty niche, it's always helpful to be able to identify what someone else's code is doing, or identify when a give problem can be partially solved using one. The Gang of Four is the go-to book for this area.

  • On the other end, anti-patterns. Being able to identify (and fix) poor design choices that can cause maintainability problems later is really valuable.

  • Memory management. Java/C# handle most of it for you, but understanding what's happening under the covers is crucial for making design decisions (i.e., how much garbage needs to be collected as a result of using this API versus a different one?). C/C++ is the king of this area, so you could use this as a reason to learn a new language.

  • Functional programming (Scheme, Lisp). It's really different from imperative (Java, C#, C++) programming.

  • Advanced features of languages that you already know. Generics, operator overloading, etc. You might know many of these, but I doubt you know all of them.

    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.
u/thanatosys · 9 pointsr/javascript
u/stonedead78 · 9 pointsr/IWantToLearn

Read this book: Gödel, Escher, Bach: An Eternal Golden Braid at least 3 times, and take your time.

u/tuckerg00dd0g · 9 pointsr/programming

Sounds like a good case to harness this legacy codebase in a unit test framework.

See Working Effectively with Legacy Code.

u/throwaway540999221 · 9 pointsr/cscareerquestions

Here's a book recommendation: Working Effectively with Legacy Code

u/McFuckyeah · 9 pointsr/askscience

This is the book you want to read. It walks you through every bit of how a CPU works, in an incredibly approachable way. (If you can understand a light switch, you can understand this book.)

u/akevinclark · 9 pointsr/AskProgramming

These are great suggestions. The three books I typically give devs early (that fit in well with the two presented here) are:

Refactoring by Martin Fowler

This is a list of patterns of common refactoring a and how to do them safely. It’ll help you recognize transforms you need to make in your code as it changes.

The Pragmatic Programmer by Dave Thomas and Andy Hunt

This is a great guidebook for how to get better at being a software engineer. Essential read.

And while there are lots of options for design patterns books...

Head First Design Patterns was the one that helped me internalize them. Even if you aren’t writing much (or any) Java, the method of teaching is hugely valuable.

u/threechewz · 9 pointsr/AskComputerScience

Well, there's the classic, Clean Code, which I haven't read but have seen recommended as a great book on this topic. But, in my opinion, as with anything else in programming, you get better by doing, and that includes writing better code. The more code you write the more you'll see basic patterns crop up and you'll start to realize what does and doesn't work. Does inheritance make sense here or should I use some type of composition. Is it worth refactoring this piece of code out to a more general abstraction. When I write, I try to have the mindset that someone else will be using my code in the future and I should write my code in a way that is as accessible for them as possible.

u/beaverjacket · 9 pointsr/AskReddit

This book is a very good explanation of how computers work. It starts with explaining electromechanical switches, and how you can turn a couple switches into a logic gate. Then, it shows how you can put logic gates together to do arithmetic. It goes on like that until you reach programmable computers.

u/Whoopska · 9 pointsr/Python

I think Working Effectively with Legacy Code is the classical book on the subject. My personal recommendation is to write a test for every piece of code you read. It doesn't have to be a perfect test, but giving yourself something that will keep your understanding tied to the code and which you can pdb through if you lose understanding will be really helpful. At a certain point, you have to say screw the side-effects and construct a large numpy array and pass that in, create some files in weird places, or inline some text to make it work. Take the time to do things the right way and they'll go faster.

u/martoo · 9 pointsr/programming

Smalltalk Best Practice Patterns by Kent Beck. In my opinion, it's his best book. It's a great book on the nitty gritty of coding.. great for all programmers. It's easy to read even if you're not a Smalltalker; all you have to do is google for a Smalltalk cheatsheet.

I also like Working Effectively with Legacy Code. It's about the sort of code that most of us confront daily: how to deal with its problems, and get it under test so that you can refactor it or add to it without gumming it up.

u/mysticreddit · 9 pointsr/gamedev

Actually, it's a bit of both.

Problems / Criticism of GoF


1. The GoF was written in the era of "OOP is a silver bullet" and single-threaded programs by academics who were generally clueless about the importance of understanding data transforms, data caches, instruction caches, and minimizing cache misses. See: Pitfalls of Object Oriented Programming of how you get massive speedups just by understanding cache usage and re-arranging the data.

2. One of the problem with the GoF methodology is when people turn it into a religion. People start trying to apply design patterns to everything even when it isn't needed and you end up with this over-engineered, bloated, slow, clusterfuck of code.

3. Programmers who focus on performance have also been pretty vocal about "cargo cult programming" and design patterns:

  • Christer Ericson who wrote the phenomenal Real Time Collisision Detection had this to say about design patterns:

    > The “Design Patterns” book is one of the worst programming books ever. Yes, really. I’m 100% dead serious when I say that I think it has set (and will continue to set) the progress of software development back by decades. Why?! Let me offer up a parable; I will call it “The Plank.”

  • Mike Acton, the father of "Data Orientated Design" also agrees when he quoted Eric at a C++ convention:

    > "Design patterns are spoonfed material for brainless programmers incapable of independent thought, who will be resolved to producing code as mediocre as the design patterns they use to create it with."

    4. While abstraction can be a nice way to solve a problem there are ALWAYS trade-offs. The flexibility of abstraction is that you generally tend to lose efficiency. Blinding applying a design pattern means you aren't thinking about the performance issues. In today's age of multi-core software this is a huge disadvantage compared to your competitors.

    And while Ericson and Acton tend to throw the baby out with the bathwater they are speaking from years of experience of writing fast, simple code. This ISN'T an appeal to authority as they aren't just some armchair academics -- they have demonstrated they have understand HOW to write FAST code. Their experience also matches what I've seen.

    5. Another problem is that changing the hardware changes the problem. GoF doesn't take this into account.

    6. Very rarely does OOP "perfectly" model the problem. GoF ignores this.

    7. Another part of the problem is that OOP is NOT scalable. OOP has a design fallacy that "one is the common case." This is almost never the case. The common case is usually you have multiple objects. Again GoF ignores for the most part. They take a stab at it with the Flyweight Design Pattern but that isn't scale when you REALLY do have many, mutable objects such as the particles of a particle system.

    And while I am not as adamant as Ericson or Acton about being "anti-design-patterns" they DO have a point -- not understanding the strengths AND weaknesses of an algorithm makes for a poor programmer IMHO. Remember, there are THREE ways to optimize:

  • Micro-optimizations, aka Bit Twiddling Hacks
  • Algorithms -- using a better O(n) algorithm
  • Macro-optimization, aka Data-Orientated Design -- minimizing cache misses.

    Go ahead and use design patterns for your tools. But for engine/games DoD will usually solve the problem simple and faster then misapplying and blindly applying a design pattern.

    Solution


    Lastly the problem of complexity was summarized by Fred Brooks in The Mythical Man-Month

    > "Show me your flowcharts (source code), and conceal your tables (domain model), and I shall continue to be mystified;
    > show me your tables (domain model) and I won't usually need your flowcharts (source code): they'll be obvious."

    A more modern colloquialism would read:

    > Show me your code and I'll have to see your data,
    > Show me your data and I won't have to see your code.

    The secret to high performance is NOT the algorithm but to focuse on HOW the data is transformed. i.e. The first rule of optimization is:

    Know Thy Data

u/calp · 9 pointsr/java

I think the book people normally recommend for this is Effective Java by Joshua Bloch

u/chanpod · 9 pointsr/cscareerquestions

Depends on what language or area you want to specialize in.

But the basics are important. Not so much being able to solve those stupid white board tests (I would not shoot for a company that does those as a self-taught first job individual. You'll just be discouraged. I've got 6 years experience and I doubt I could pass those stupid test without extensive studying.)

It's hard to say, b/c of some of it is...just exposure and your ability to think about abstract problems. I'm honestly not sure how to word it. But people who have had to go through academic training. EG Algorithms, data structures, modeling, etc... seem to just have a better understanding of abstract processes (if that makes sense).

Some things I feel are personally important.

Clean Code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_2?keywords=clean+code&qid=1563404400&s=gateway&sr=8-2 Believe this is the one. I've never read it page by page but we had one college professor who basically taught the concepts from it.

Ability to actually talk about what it is you've done and know. The best way to do this is to have actually tackled a complex problem or project. Even if you need to make one up, you'll learn a lot. Things like properly structuring objects. Data flow. Singletons. Data storage. Security (if you're doing something web based). I personally built an entire website from the ground up. It included a content management system for the homepage. Custom permissions and a forum's section. I learned more from that personal project than I have from work honestly. It's now trashed in Github somewhere, but that wasn't the point.

Abstraction abstraction abstraction. This kind of goes with the clean code point.

Knowing the importance of testing. Difference between unit and e2e (if you're doing web). Some companies don't even write test so your mileage may vary on this one. Usually they still pretend like they do in the application and interview. But once you get in, they'll have zero test. And this isn't the worst if the application isn't very large or complex. There's a lot more to test but unless you're applying for that kind of position, it may not be as important. But being able to talk to some of the basics is good. (Like knowing some terminology. Black box testing, smoke testing, uhh, drawing blank on the others...you can tell what jobs I've had sigh...)

I would say the tl;dr is...actually make something. And not something simple. And do it right. This will give you a lot of things to learn and think about and discuss in an interview. It'll make you more engaged and willing to learn. And most importantly, it'll demonstrate you can actually do what you say you can.

u/xunlyn85 · 9 pointsr/csharp

I generally agree, but the problem with patterns is some folks try to shoehorn everything into a pattern sometimes turning something simple into something more complex than it needs to be.

​

I find that following SOLID with YAGNI at the back of your mind tends to be what seems to work best for me


Along the lines of patterns: I'd recommend Head First Design Patterns

u/tokyo7 · 9 pointsr/programming

No, it would be better to just raise the point in the next stand up meeting, perhaps get a senior dev to sit with you while you figure out why the crap was written originally (Was it just a short cut?), whether it's needed any more or whether it should be re-written properly.

Once that decision has been made, the code and the horrendous comment can be removed or replaced by a more suitable solution.

We live in a modern age of modern source control, we do not need to leave messy large comment blocks all over our code.

I recommend the book 'Clean Code' http://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

u/astronothing · 9 pointsr/Unity3D

Learn some design patterns: http://gameprogrammingpatterns.com/

Follow the SOLID principles: https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)

Read "Clean Code" (and everything else by Robert C. Martin): http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

u/chazzlabs · 9 pointsr/androiddev

> 5 - I've always struggled with this, anyone i talk to says comment your code, i just never see the use for me. ITs something im working on.

Clean Code: A Handbook of Agile Software Craftsmanship

Read that book, and start applying the techniques as you finish each chapter.

u/h-town · 9 pointsr/webdesign

Designing for the web? First thing to do is read "Don't make me think." It's a thin book you should be able to knock it out in no time.

If you are coming from a print world remember CMYK and inches mean nothing, this world is RGB and Hex colors and pixels. Telling the web guy you want a 15% tint of a Hex color isn't helpful.

Be aware the site, text and text flow will look slightly different depending on the browser and platform. How the page, text and forms look on a Mac in Safari is not the same as a PC with IE7 (or 8 or 9) or a mobile device. Your careful word wrap and precise leading is going to be lost.

Map out the likely clients who are the target of the website and their likely viewing device and browsers. Design for those first. If you are designing a site targeting corporations chances are the viewing will be on a PC with some version of IE. If you are designing a site for photographers targeting designers and ad agencies then a Mac with Safari or FF is your most likely target. If most of your viewers are going to be on laptops or mobile devices keep that in mind first.

Include a Photoshop page with all the main colors used. Text color(s), link colors (link, visited, hover and active colors) and all other colors (background, page, dividers, etc.) that will be showing up.

Finally, online is not like working in InDesign, Quark, Illustrator or even Photoshop. Approve everything at 100% size. Just because the vector files, and 6 point type, look great at 1200% in Illustrator doesn't mean they will translate to 72 ppi in a browser.

Other than that, what everyone else said.

u/solid7 · 9 pointsr/linuxadmin

A lot of what has been suggested is great for learning linux. Realize that "out there" very little is served out of a single box (and if it is you're doin it wrong). Production infrastructure likely looks and acts very very differently from your home linux workstation. Just because you know how to type sudo apt-get install apache2 does not mean you are ready for a full ops position... BUT - if you put in the wrench time and pay your dues, you will get there.

Here are some areas that would be good to build your knoweldgebase up in...

  • First and foremost - you must build the ability to learn how to figure things out and build an intuition of what to inspect should something not be working. This comes from having a working knowledge of many different systems in a large heterogeneous environment. This will come with experience.
  • Learn some of the rapid deployment frameworks - cobbler, puppet, cfengine, etc... No one sits around configuring each and every production machine from scratch.
  • Now that you are familiar with (presumably) the installation and configuration of apache, start thinking about setting up caching/proxy infrastructure. Get a sense for what to use for load balancing v.s. caching v.s. increasing availability (and some combination of the three). Become familiar with things such as nginx, mod_proxy, haproxy, squid, varnish, mongrel, etc...
  • You MUST know how dns works. Crickets bind and dns should be considered required reading. Any lack of understanding of how dns works is simply unacceptable for a proper sysadmin.
  • this book is required reading, period.
  • You must become familiar with centralized authentication mechanisms. Most systems utilize something called PAM. Learn how to configure PAM to reference slapd, AD, etc... Kerberos is our current preferred central authentication mechanism, you need to know how to bounce kerberos tickets around. Get slapd (OpenLDAP) up on its legs.
  • When running a linux kernel, learn how to configure netfilter. Under linux, Netfilter is the thing responsible for routing, nat, and packet filtering. Understand that other kernels do not use netfilter (or commonly use something else). Become familiar with the common kernels firewall, routing, and forwarding system(s). Don't make the mistake of saying "the iptables firewall..." in the interview room! Iptables is not a firewall.
  • Know your basic networking. Internet core protocols should be added to your list of required reading. Understand the differences between a hub, bridge, switch, and router. Learn how to "subnet", which means knowing your binary math! I cannot tell you how many times I have seen a messed up network because someone didn't know how to figure out /27 and keyed in the wrong values from a "subnet calculator". Along with networking do a bunch of reading/research on vlans, trunking and stp. Most people cannot tell you what a L2/3 managed switch is or how it differs from a "dumb" switch or router. Don't be one of those people! Learn how to configure routing protocols such as BGP, RIP and OSPF (also, learn basic computational graph theory). You may not end up doing a whole lot of networking, but it's really good stuff to know.
  • Virtualization is important. You need to know the different forms of virtualization (desktop v.s. os-level v.s. para v.s. hyper virtualization). If you are keen to linux, you need to know how xen and kvm work (this is typically what commercial vps's typically use). Also look at vmware and virtualbox for desktop virt. For os-level virtualization, you need to know how to use LxC and jails.
  • Learn how LVM works! Spend some time familiarizing yourself with LVM2 (linux), vinum (BSD), and ZFS's container framework (Solaris/BSD). Know how and when to use raid. Make sure you understand the implications of the different raid configurations.
  • Learn common backup methodology. Raid is not backup, don't make this mistake.
  • Get used to doing everything on the command line, and always think "what if I had to do this on 20,000 servers?".

    So off the top of my head there's a bunch of things you could study. I think that's quite a bit to get your head around, and a deep understanding of some of these topics will only come from working experience. There may be a LOT of work to do in some of those areas. Getting a fully functional xen (or kvm) based system up and on it's legs is not an easy task for the uninitiated. It is my opinion (and everyone else is free to disagree with me) that all good sysadmins/ops/engineers need to "grow up" in some area of lower level technical position. That can be a jr. admin position, the helldesk, or whatever else... This will give you the "systems" working experience that will let you branch into a full fledged admin/op position. Getting some certs under your belt can help you get in the door, but by all means isn't required. Cert's cost money and (the ones worth getting) take time. Personally, I tend to stray away from places that make a big deal out of certs... but that's just me.

    tl;dr: Learn how to learn. Pick something you don't know how to do and leverage a linux system to accomplish that goal - rinse and repeat.
u/Sancty · 9 pointsr/javascript

Clean code... you can find it on amazon or anywhere else. Pretty highly regarded.

Edit: http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

u/edwilli222 · 9 pointsr/AskProgramming

This is kind of a weird one but I’d suggest Code. Very non-technical, no programming, but cool history and fundamentals.
Code: The Hidden Language of Computer Hardware and Software - Code: The Hidden Language of Computer Hardware and Software https://www.amazon.com/dp/0735611319/ref=cm_sw_r_cp_api_i_IiH2DbWSNWHMW

u/vfxdev · 9 pointsr/learnprogramming

Android is java, there is 100 million devices right there.

I know Java, along with a handful of other languages used on the JVM (kotlin, scala). I also use Python quite a bit, C++/ObjC (though I use it much less), and I dabble in JS if needed. I've written perl, php, pascal just to new a few others. Once you learn the fundamentals of CS, you should be able to grasp any C like language pretty quickly. (even C++ if you just keep it simple)

What you should focus on is learning object orientation. Relationships between different objects/classes, their interfaces, and how to actually construct software. Don't worry about language so much yet, you will quickly get the point where you know 5+ languages.

Now go read this book.
https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X

Also, I have to say that knowing Java and Python is a sought after combination.


u/TehLittleOne · 9 pointsr/learnprogramming

My suggestion is always to start with Python. It's a very high level language and it's very easy to learn. In fact, Python recently became the most popular language to teach beginners. I know you wanted to learn Java, but there are several things about it that make it not so great for beginners, as well as several things about Python that make it good for beginners (ask why if you're interested, but it may be a bit technical). As a programmer, you will likely learn a dozen or more languages (I've learned over a dozen in school), so saving Java for a bit later isn't really an issue. You'll find in programming that a lot of the important things apply to most languages, so learning these allow you to apply them to new languages quite easily. My university now uses this book in the first year computer science courses.

Get yourself situated with a free GitHub account. GitHub is my favourite version control. If you have a student email you can get a free private repository (so others can't see your stuff). If you don't have a student email to use to get one, you can still make a free account, but it will be public. What that means is that anyone who navigates to your account can see all your code. Since you're just starting out, it shouldn't matter if people browse your code, there's not much to see since it's just you going through the basics. GitHub has a tutorial for new users and also has a user-friendly client that makes it all really simple. You can save the more complex stuff for later until you're comfortable.

Once you've gone through Python and learned a bit, it's time to get into some of the language-independent things. Introduction to Algorithms is an amazing textbook. The authors are some of the most well respected people in the field and I've used it in school in more than one course. You can go through this at any time. I recommend you programming some of the things (they provide some code as well), and perhaps trying this stuff in Java might be a good segway from Python to Java.

u/regexpressyourself · 9 pointsr/learnprogramming

I liked "Don't Make Me Think" for basic user experience and layout stuff. It's mostly about web design, but it can definitely apply elsewhere.

u/DoUHearThePeopleSing · 9 pointsr/ethereum

Did you read any mathematical papers, are you familiar with university-level math, or with computer science?

What might help you get familiar with this style of writing is Concrete Mathematics ( https://notendur.hi.is/pgg/(ebook-pdf)%20-%20Mathematics%20-%20Concrete%20Mathematics.pdf ), or Introduction to Algorithms by Cormen ( http://www.amazon.com/dp/0262033844?tag=top-books-cs-20 ).

The first book is more about math, but it's a nice and fun read. And it will make you familiar with math notations. The other book is about algorithms and data structures - difficult to read, but once you get through the first chapters, reading things the Yellow Paper should be much easier. Protip with Cormen - skip the proofs at first :)

Most developers, even the ones familiar with architecture and design patterns, aren't familiar with the theoretical/mathematical groundwork behind all this.

In other words: the paper is written for computer scientists, not developers really. Many excellent developers are shit computer scientists and vice versa.

u/dc_woods · 9 pointsr/web_design

As a person with no education beyond high school, take all that I say with a grain of salt. I'm a pretty successful web designer and front-end developer, having working with four startups and done a year of freelancing.

It is not uncommon to hear industry peers criticize the education system as it pertains to web design because often the practices you learn are no longer the standard or relevant. I've heard of many stories where designers exit college (with no working experience, obviously) and have an incredibly difficult time finding work for the reasons I listed above.

Education has never been brought up at any of the companies I've worked or those that I've consulted with. I believe the reason for this is that I have a body of work to show along with whatever reputation I've garnered on Dribbble, say.

All this being said, it is entirely possible for you to develop your skills on your own, such as I did, and find work. I'm happy to list all the reading materials that I own that helped me get where I am now. I'll list what I remember but I'll have to go check when I can get a second:

Hardboiled Web Design
HTML5 for Web Designers
CSS3 for Web Designers
The Elements of Content Strategy
Responsive Web Design
Designing for Emotion
Design is a Job
Mobile First
The Visual Display of Quantitative Information
The Elements of Typographic Style
Thinking with Type
The Icon Handbook
Don't Make Me Think

If you invest your money in those and actually read them, you will be well on your way. Feel free to ping me. Good luck!

u/emtuls · 9 pointsr/netsec

Hey /u/Xerack! I'm the original author of the post linked here.

Appreciate the feedback! If you think I could clarify anything better, please let me know.

As far as resources for Reverse Engineering, I can provide you with a baseline that I would recommend starting with.

x86 Assembly:


If you don't know assembly language at all, this list of videos was where I picked up a decent amount of x86 assembly language.


A few good books would be:


  • Hacking: The Art of Exploitation I am a huge advocate for this book. I learned a lot from this and have read it multiple times. It is written very well and teaches someone with no experience how to do C programming and assembly. This is mainly a book for learning exploitation/vulnerability research, but that can play hand and hand with Reverse Engineering. It will show you the assembly language break down of basic exploits and this can help you with RE.

  • Practical Reverse Engineering I read through the beginning of this book and it gave me some good foundations of understanding memory and computer architecture for RE along with assembly of course

  • Secrets of Reverse Engineering This book is a bit in depth, but the beginning gives another good foundation for Comp Architecture and assembly stuff.

  • The IDA Pro Book Haven't personally read this book yet, but I have been told it is the defacto standard for learning IDA Pro, and it has examples you can learn from.

    Hands On:


  • Legend of Random Very useful hands on with tutorials. Mainly based on cracking, but that requires reverse engineering. Highly recommend this!

  • Lenas Tutorials Again, another awesome hands on tutorial, mostly based on cracking as well.

  • Crackmes These are more of challenges once you start to have a little understanding down

    Courses:

    Tons of courses on youtube. I learn well from visual, so I recommend these youtube videos:


  • Basic Dynamic Analysis
  • Real World Decompilation There are a few videos to this series and he disassembles a game, definitely nice to learn from.


    Beyond that, Google will always be your friend, and /r/reverseengineering. I also have a bunch of material for Malware RE, but that's a bit different than Software RE, though it is relatable.
u/okmkz · 9 pointsr/java

> Look for a book on object oriented programming

For this I recommend both Head First Java and then follow that up with Head First Design Patterns.

u/akmark · 9 pointsr/programming

I'll recommend Code, even though it isn't specifically theoretical. However, it does go over how code (semaphore, morse code) evolved over time. From someone who does program this is about a 'human' a book as they come which could fit exactly what you are looking for.

u/DevilSauron · 9 pointsr/programming

I've been personally learning C++ from this book and it's really good. The only problem is that it talks only about C++11 and not 14 and 17 versions, but these new versions are relatively minor compared to C++11 and there's no better and more comprehensive book that talks about the most modern versions...

u/s32 · 9 pointsr/jobs

That being said, some websites simply aren't going to be enough. Codeacademy is awesome, but don't expect to learn algorithms from it; you probably would want to pick up a copy of CLRS and do the MIT course

u/phao · 8 pointsr/cscareerquestions

The best way I know how is by solving problems yourself and looking at good solutions of others.

You could consider going back to "fundamentals".

Most programming courses, IMO, don't have nearly as many exercises I think they should have. Some books are particularly good on their exercises list, for example K&R2, SICP, and TC++PL. Deitel's has long exercises lists, but I don't think they're particularly challenging.

There are some algorithms/DS books which focus on the sort of problem solving which is about finding solutions to problems in context (not always a "realistic" one). Like the "Programming Challenges" book. In a book like that, a problem won't be presented in a simple abstract form, like "write an algorithm to sort numbers". It'll be inside some context, like a word problem. And to solve that "word problem", you'll have to find out which traditional CS problems you could solve/combine to get the solution. Sometimes, you'll just have to roll something on your own. Like a new algorithm for the problem at hand. In general, this helps you work out your reduction skills, for once. It also helps you spotting applications to those classical CS problems, like graph traversal, finding shortest plath, and so forth.

Most algorithms/DS books though will present problems in a pretty abstract context. Like Cormen's.

I think, however, people don't give enough credit to the potential of doing the exercises on the books I've mentioned in the beginning.

Some books I think are worth reading which also have good exercises:

u/vampire_kitty · 8 pointsr/webdesign

Don't Make Me Think is an interesting book that if you can find it in your local bookstore and browse through it might be helpful. It's a small book so you could scan through and see if there are interesting bits that might be useful.

On the whole, though, I'd suggest you find an editor to SEVERELY cut down the amount of text that needs to be read for instructions if you find that people aren't reading it.

Page 45 of the book I mention is a chapter called Omit Needless Words (needless is crossed out). A couple of quotes from the chapter:

"E.B. White's seventeenth rule in The Elements of Style:

"17. Omit needless words.
"Vigorous writing is concise. A sentence should contain no unnecessary words, a paragraph no unnecessary sentences, for the same reason that a drawing should contain no unnecessary lines and a machine no unnecessary parts."

On the next page a section starting with the bold line:

"Instructions must die

"The other major source of needless words is instructions. The main thing you need to know about instructions is that no one is going to read them - at least not until after repeated attempts at "muddling through" have failed. And even then, if the instructions are wordy, the odds of users finding the information they need is pretty low.

"Your objective should always be to eliminate instructions entirely by making everything self-explanatory, or as close to it as possible. When instructions are absolutely necessary, cut them back to the bare minimum."

Then there are some examples. The writer is a consultant for web usability and has been doing it for years and the suggestions are based on his (and others') research. You are finding the same thing that others are finding: they aren't going to read the instructions. See if you can find another way. If you want some ideas, poke through the book (or others that are like it) and see if you can configure a method that makes it self-explanatory as suggested by the writer.

Without seeing the site itself, I cannot offer much else.

Good luck!

u/JohnKog · 8 pointsr/compsci

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)!

u/jbacon · 8 pointsr/java

Since you're already a programmer: Effective Java, 2nd Edition. That's pretty much your definitive Java language and Java best practices reference.

I would not recommend the Head First series - those are more geared to novice programmers. I don't think you'll have much trouble picking up basic object oriented concepts, which is probably the only thing that book might help you with.

For general programming reading, I recommend The Pragmatic Programmer - great read, lots of excellent advice in there.

u/shaggorama · 8 pointsr/learnprogramming

Probably the best book on "thinking like a software engineer" is Code Complete.

For now, here are a few general tips off the top of my head:

  • Build your toolkit as you go. Don't just be trying to construct abstractions. You should be hunting for useful abstractions. Write code that is reusable. Whatever code you wrote is solving some sub-problem of your larger solution: are there related sub-problems you could attack with a similar strategy? Can you tweak some piece of code such that it can be reused to make your life easier elesewhere?

  • Code as documentation. You are not just writing code for the purpose of accomplishing some end-goal, you are writing code so that if something breaks down the line, you will be able to figure out what needs to be fixed. This means your code should explain itself. Even if you don't anticipate anyone other than yourself will ever see your code, it might be months or years before you revisit some old code and you should anticipate that you will have forgotten basically everything about how it works. How can you make "future me"'s life easier in the process of building some solution? You should always be trying to name and structure variables/functions/objects such that it's clear what your code is doing and how information and decisions flow through your program.

  • Solve for scalability early. Premature optimization should generally be avoided, but it's often the case that there are small changes you can make very early on to make your code orders-of-magnitude more performant. Are you choosing appropriate data structures for the problem? Are you factorizing your code and dependencies in a reasonable way? Are you excising unused dependencies from your code? Are you limiting i/o? Are you moving large chunks of data around? Can your code be containerized into microservices?
u/rafuzo2 · 8 pointsr/androiddev

Here's a rough outline, from high level to low(ish):

  • Fundamentals of Object Oriented Programming. Understand basic concepts like inheritance and encapsulation and why you'd use them. Any book with these words in the title/subtitle should be able to get you the basics, pull a highly-rated book off Amazon for recommendations.

  • (This is optional but highly recommended) Learn basic design patterns such as those presented in the Gang of Four book. These aren't required for writing Android apps but the more you understand about patterns the more it'll help you later on. You don't need to master this stuff at the outset so just read at your leisure.

  • Learn Eclipse. It's a big subject and for seasoned veterans the various components can be confusing, but you should know how to use an Integrated Development Environment regardless.

  • Follow the tutorials that VersalEszett mentioned.

    Extra Credit
  • Get an account on Github and understand how Git works. It's free unless you want private repos. Google around, find android development projects that are public, clone the repos and walk through the code - retype it line by line if you need to. Try to figure out why things are broken out the way they are.

    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.
u/Updatebjarni · 8 pointsr/learnprogramming

K&R is the book for C, especially if you have prior programming experience.

u/prego_no_pao · 8 pointsr/portugal

acabei de ler o Code (1999). É uma boa introdução ao funcionamento de um computador baseada na sua evolução na história.

u/Ubby · 8 pointsr/webdev
u/antininja · 8 pointsr/gamedev

> I first build a very simple prototype that has some basic actions and game principles I want to have in my game. I do not care for design nor code quality.

IIRC, this technique is highlighted in Code Complete. The key point the author made there was that it's OK to take shortcuts while prototyping, as long as you're willing to throw all that code away before doing the real work. (Of course, it's not that black and white.)

u/headbox · 8 pointsr/italy

Il mondo della programmazione è incredibilmente vario, ti consiglio di cominciare con qualcosa che stuzzichi la tua voglia di fare, potrebbero essere le applicazioni web, oppure sviluppare su android o iphone, come la programmazione di videogiochi oppure realizzare un programma per windows o per linux.
Una volta capito cosa ti piacerebbe provare indirizzati su qualche tutorial veramente basilare, e impara facendo.
Se dovessi indicarti un linguaggio da cui cominciare non avrei dubbi: il C.
Non C++ mi raccomando ma il C puro.
Esistono diversi testi incredibilmente validi e oltre alla Bibbia ti consiglio di farti un giro su amazon per cercare qualche introduzione a qualche argomento o linguaggio specifico, tipo "coding for dummies" ecco.
Il python potrebbe essere un linguaggio buono per cominciare a capire, oppure il javascript a livello base.
Quindi in sostanza io ti consiglio di seguire due strade parallele allo stesso tempo, da una parte di fai un pò di culo con le basi, quindi imparando il C, dall'altra puoi divertirti a sperimentare con le tecnologie più recenti. Ad esempio su codeacademy puoi già cominciare a fare pratica di javascript (penso ci siano altri linguaggi disponibili).
Gli argomenti base che dovresti cominciare a studiare riguardano la programmazione procedurale ad oggetti.
Esistono altri paradigmi di programmazione come ad esempio quella funzionale ma al momento lasciala pure stare.
Ovviamente tutto in inglese, mi raccomando.

u/cyanippus · 8 pointsr/france

La plupart des formations t'apprendront rien d'utile mais prendront volontiers tes thunes.

Sinon t'as le CNAM, c'est bien, si tu veux à tout prix un vrai diplôme (ça aide à trouver le premier taff).

Tu peux aussi faire ça en solo :

  • Installe toi un Linux (VM ou dual boot, mais si tu veux t'y mettre à fond fais en ton OS principal).

  • Si tu sais pas quel système choisir, t'as le choix entre Ubuntu (facile), Debian (le must et pas si difficile) ou Arch Linux (tu vas en baver au début mais c'est ultra formateur).

  • Refais tout ce que tu faisais sur ton système actuellement mais avec Linux et les outils du libre.

  • Tu peux aussi réviser et passer la LPIC 1 en parallèle avec un livre ou des ressources gratuites.

  • Maintenant que tu connais la ligne de commande, bash, quelques services basiques et comment les gérer, apprends un langage de scripting type Python.

  • Apprends à te servir de Git.

  • Tu veux devenir dev ? Apprends le C.

  • Trouve toi un projet qui t'intéresse sur GitHub et essaye d'y participer.

  • Si le C ça t'a vraiment plu, tu peux essayer de participer au développement du kernel.

  • Si t'aime bien Linux et ses distros et que tu veux en savoir plus sur ce qu'il y a sous le capot, tu peux créer ton propre système.

  • Suis r/linux et r/programming sur reddit pour rester dans la boucle, y'a pleins d'autres sous reddit pour débutant aussi en cherchant un peu.

    Bref si tu fais rien que la moitié de ce qu'il y a dans la liste t'es facilement employable comme admin sys en apprenant quelques bases des réseaux . Avec python et de la virtualisation en plus t'es en chemin pour devenir devops (l'un des profils les plus recherché sur le marché).

    En plus tu seras plus compétent que la majorité des bonhommes sortis de formations privées à la noix.
u/chindogubot · 8 pointsr/compsci

I get teased by people that I am one of only 3 people in the world to have actually finished this book, one of those being the author and the other being the person who recommended to me, but Godel, Escher, Bach: An Eternal Golden Braid was pretty interesting. It covers the profoundness of the topic and is interspersed with Alice in wonderland style dialog that comes at the topic from another angle. Deep but captivating overall.

On a tangent, Goedel's theorem and Turing's incompleteness theorem, along with some other mathematicians who have gazed out over the edge of logic and gone somewhat mad are covered in the BBC documentary Dangerous Knowledge.

u/KevinJD · 8 pointsr/webdev

Took me too long to figure out the search box wasn't a button.

Don't make me think

Edit: Its not even a cursor on mouseover in chrome.

u/kgtx · 8 pointsr/lowlevel

OSDev - http://wiki.osdev.org/Main_Page

Kernel programming - http://stackoverflow.com/a/12818021

Books:

Hacking the Art of Exploitation - This is a fun book that has a lot to do with programming in C, exploring memory and disassembly.

Practical Reverse Engineering - this is a very informative and short book which is pretty close to the metal in regards to memory and all that but is strongly focused on its namesake so I wouldn't get it if it's not your thing.

LittleOS Book - like 76 pages on building your own OS (also free!).

u/TehUberAdmin · 8 pointsr/javascript

But for the love of God, please, please, learn JavaScript itself to a good standard before even touching jQuery.

Even though jQuery makes writing web apps a lot easier and saves you a lot of development time, it is still a JavaScript library and as such, if you don't have a good grasp of JavaScript, you're going to be writing jQuery code that may well work correctly, but you're not going to have any idea why it works correctly and as such, debugging and writing advanced jQuery code is going to be a nightmare.

I appreciate that you might not want to spend any money on learning JavaScript, but if you're really interested in the language and want to know it well (and you already have a solid foundation in programming), then I highly recommend getting JavaScript: The Good Parts and reading through that. It's short (176 pages), you can read it in an afternoon (though the first time round, some of the stuff might go over your head), and although it may be very opinionated, most of what Crockford says is pure gold and at the end of it you will have a thorough understanding of how JavaScript works and how you can write good JavaScript, which will aid you tremendously when you start using libraries such as jQuery.

Apologies for my rantiness, it's just that JavaScript is seen as a 'toy' language by many, a simple language that people can just jump in and use without learning it first, as evidenced by people suggesting diving straight into jQuery, which is a reputation that I think is undeserved. JavaScript may not be the prettiest of languages, but it's here to stay, and if you learn to use it properly, you'll find that beneath the design mistakes lies a simple and beautiful programming language that just wants to be loved.

u/Daganar · 8 pointsr/programming

For anyone interested in this kinda stuff I would really recommend "Code: The hidden language of computer hardware and software"
https://www.amazon.co.uk/Code-Language-Computer-Hardware-Software/dp/0735611319

u/jeykottalam · 8 pointsr/compsci

Introduction to Algorithms by CLRS

TAOCP is a waste of time and money; it's more for adorning your bookshelf than for actually reading. Pretty much anyone who suggests TAOCP and is less than 55 years old is just parroting Standard Wisdom™.

Godel, Escher, Bach is a nice book, but it's not as intellectually deep in today's world as it was when first published; a lot of the memes in GEB have been thoroughly absorbed into nerd culture at this point and the book should be enjoyed more as a work of art than expecting it to be particularly informative (IMO).

If you're interested in compilers, I recommend Engineering a Compiler by Cooper & Torczon. Same thing as TAOCP applies to people who suggest the Dragon Book. The Dragon Book is still good, but it focuses too much on parser generators and doesn't really cover enough of the other modern good stuff. (Yes, even the new edition.)

As far as real programming goes, K&R's The C Programming Language is still unmatched for its quality of exposition and brevity, but these days I'd strongly suggest picking up some Python or something before diving into C. And as a practical matter, I'd suggest learning some C++ from Koenig & Moo's Accelerated C++ before learning straight C.

Sipser's Introduction to the Theory of Computation is a good theory book, but I'd really suggest getting CLRS before Sipser. CLRS is way more interesting IMHO.

u/Omnicrola · 8 pointsr/java

I'm surprised nobody has recommended Clean Code by Robert Martin, which has good advice for keeping code clean in any language. Examples are given in Java. It echoes a lot of the advice given here, as well as explaining the reasoning behind the practices.

u/csp256 · 8 pointsr/cscareerquestions

Good news is you have previous experience and C is a very simple language.

Learn C The Hard Way has some weird shit in it (wtf does "make is your Python now" even supposed to mean?) but it is largely good and do tend to recommend it despite the warts.

Really though, why not go straight to the source?

Just make sure you master pointers. It is really useful to understand what memory is on a physical or near physical level to understand pointers. It is one of those concepts that makes instant sense if you come from a hardware point of view, but can trip up newbies with a software point of view.

u/fiskfisk · 8 pointsr/compsci

Code: The Hidden Language of Computer Hardware and Software from Charles Petzold does just that, starting from the simplest form and going through all the different steps we took to get to where we are today. Well worth a read!

u/dustinin · 8 pointsr/Design
u/CS_Student19 · 8 pointsr/computerscience

Tough call. I mean it sounds like you're setup pretty comfortably, so you don't really need any material goods. That's a great place to be.

Perhaps instead of some gift that can be purchased and wrapped in a box, you could do something else.

This might give you some ideas or perhaps they could find something unique, like an autographed copy of "Intro to Algorithms". I'm really just throwing stuff against the wall at this point, but maybe it might spark an idea.

u/bRUTAL_kANOODLE · 8 pointsr/sysadmin

If you haven't read The Practice of System and Network Administration yet I would suggest starting there. It is an easy read and very informative. It helped me get into the mindset of a sysadmin.

u/slacker87 · 8 pointsr/sysadmin

This book is one of the best out there for overall real world sysadmin knowledge/practices

u/Zaemz · 8 pointsr/programming

This is awesome! I've been slowly getting more and more interested in hardware, and this is something I would absolutely love to do. I just don't know where to start.

I've been reading a couple of books about learning lower level stuff, and planned on working my way up.

I'd really like to get out of webdev and into low-level programming, or even hardware design and implementation. There's sooooo goddamn much to learn, that I doubt I'll be ready without getting a BS in Comp. Engineering, and maybe a master's as well.

(I'm absolutely a beginner, and if anyone is interested in the books I've been reading, these are they:

  1. Code by Charles Petzold

  2. The The Elements of Computing Systems: Building a Modern Computer from First Principles by Noam Nisan and Shimon Schocken

  3. Computers as Components by Marilyn Wolf)
u/dahimi · 8 pointsr/sysadmin

If you have no background in sysadmin you should definitely check this book out:

The Practice of System and Network Administration, Second Edition

http://www.amazon.com/gp/product/0321492668/

u/zwangaman · 8 pointsr/programming

Code Complete 2nd Edition is what you want.

u/CausticInt · 8 pointsr/C_Programming

Read the sidebar.

If you haven't had programming knowledge before, then The C Programming Language by Dennis M. Ritchie and Brian W. Kernighan is right up your alley.

u/LongShlongSilvrPants · 8 pointsr/cscareerquestions

Head First Design Patterns: A Brain-Friendly Guide

A relatively unique methodology of approaching design patterns (using Java examples). Understanding design patterns will transform both you and your code.

EDIT: Adding my comment below to my comment here for better visibility and description of the book:
> It can absolutely be read as an introductory book! I would recommend going into the book having a foundation in an OO language, such as Java or C++.

> This was the "textbook" we used in my Object-Oriented Design course; however, the great part about this book is that it reads more as a "narrative" than a traditional textbook. I definitely think this is the best book for learning about design patterns. The GoF book should be used as a reference, after you understand them better.

> All I can say is do not judge a book by its cover, and in this case I mean it literally. I think they are trying to be ironically cool by using stock photos on the cover and within the book. It seems odd to be reading through a "serious" book that look like that, but believe me when I say it will be an eye-opening experience.

u/dAnjou · 8 pointsr/django

Simply start by writing tests for each HTTP endpoint and check the content of the response.

Maybe check out Michael Feathers' Working Effectively with Legacy Code too.

u/gbacon · 8 pointsr/programming

An excerpt from Working Effectively with Legacy Code by Michael Feathers:

> Unit tests run fast. If they don't, they aren't unit tests.
>
> Other kinds of tests often masquerade as unit tests. A test is not a unit test if:
>
> 1. It talks to a database.
>
> 2. It communicates across a network.
>
> 3. It touches the filesystem.
>
> 4. You have to do special things to your environment (such as editing configuration files) to run it.
>
> Tests that do these things aren't bad. Often they are worth writing, and you generally will write them in unit test harnesses. However, it is important to be able to separate them from true unit tests so that you can keep a set of tests that you can run fast whenever you make changes.

u/Hawk_Irontusk · 8 pointsr/iOSProgramming

You should read Working Effectively with Legacy Code by Michael Feathers. It's a fantastic book and will help you avoid the classic mistakes.

u/Orangy_Tang · 8 pointsr/cpp_questions
  1. Automated builds / repeatable builds.
  2. Automated testing of new version output vs. old version output when given identical input.
  3. https://www.amazon.co.uk/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052/
u/zxxzwqw · 8 pointsr/programming

Pragmatic Programmer is over a decade old, but I doubt you'll more useful advice.

u/fesor · 8 pointsr/PHP
u/MoonShadeOsu · 8 pointsr/ProgrammerHumor

Sounds like you need this.

Good luck!

u/rockinghigh · 8 pointsr/leetcode

You're essentially asking for a computer science class on algorithms. I would recommend:

u/codeificus · 8 pointsr/programming

The 86 stands for the instruction set for the cpu. Basically, every chip designed in the world accepts input and output, but in different ways (different numbers of connections, ordering). All of those chips have more or less backwards compatibility with regard to that, so it makes it easier for others to develop around that.

So there is a meaning conveyed, though it probably isn't important to you if you aren't developing hardware or writing assembly.

I strongly recommend Code by Charles Petzold which explains the origins of these chipsets. Basically Intel put out the 8080 in 1974 which was an 8-bit processor, then the 8086 in 1978 was a 16-bit processor, so they just ran with the number scheme (6 for 16 bit). The "80" from 8080 probably came from IBM punchcards which were used for the US census (since the 1920s!), which is actually how IBM started, basically as the child of Herman Hollerith who built automated tabulating machines in the late 19th century. Also this is to blame for the 80-character terminal convention. Blame IBM.

u/logan_capaldo · 8 pointsr/programming

Martin Fowler did not write Working Effectively with Legacy Code, this guy did.

u/Antoak · 8 pointsr/sysadmin

I started in the same boat as you, but I've been doing this for a few years now. Probably worse than someone who came up in a very structured environment.

Get a orchestration mgmt system setup, like salt, puppet, chef, etc.

Get monitoring set up if you haven't already. Central logging and automatic alerting, etc. If you have time, set up visualization for logs so you can see trends, using things like splunk or elk.

Make sure you have backups, and make sure you can actually restore from backups.

These are good, and written by someone with way more experience than me: 'The Practice of System and Network Administration, Second Edition', 'Time Management for System Administrators'

u/SolenoidSoldier · 8 pointsr/ProgrammerHumor

If you're interested, check out Clean Code. There is a chapter on just this. Put simply, you shouldn't be afraid to add length to your variable names, so long as they can concisely describe their function. I know, easier said than done, but it's helped steer me away from using acronym and single-letter variable names.

u/munificent · 8 pointsr/ruby

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.

u/enzlbtyn · 8 pointsr/cpp

I'm a bit confused on your background with CS. You are you are aspiring to become a machine-learning researcher, yet evidently it doesn't seem like you have much of a background in CS which is why you're asking I assume. In any case, I'd recommend reading books on C++ and books on data structures/algorithms separately.

For algorithms/DS I recommend The Algorithm Design Manual and Introduction to Algorithms (commonly referred to as CLRS). Recommended books for C++ are on isocpp.org.

If you want to learn machine learning concepts and algorithms then I recommend some books on artificial intelligence and machine learning. To start with, Artificial Intelligence: A Modern Approach
then ISL. And/or potentially some associated MOOC courses, I recommend Learning from Data it's a really good course which teaches you fundamentals in machine learning such as learning theory and asks questions for why you can learn and etc.

In general, with all these books, you could possibly learn C++ by implementing their exercises or specific algorithms. Some examples would be basic CS related things binary search, sorting algorithms, heaps/priority queues and their associated implementations in the standard library. Then specific to Machine Learning you could implement decision trees and as an extension AdaBoost, a perceptron or a more generic neural network, and the list goes on.

u/help_me_will · 8 pointsr/actuary

Against The God: the remarkable story of Risk- Outlines the history of probability theory and risk assessment through the centuries

https://www.amazon.com/Against-Gods-Remarkable-Story-Risk/dp/0471295639/ref=sr_1_1?s=books&ie=UTF8&qid=1475105434&sr=1-1&keywords=against+the+gods

When Genius Failed - A narrative of the spectacular fall of Long Term Capital Management, a hedge fund which had on its board both Myron Scholes AND Robert Merton (you will recall them from MFE)
https://www.amazon.com/When-Genius-Failed-Long-Term-Management/dp/0375758259/ref=sr_1_1?s=books&ie=UTF8&qid=1475105453&sr=1-1&keywords=when+genius+failed

Black Swan/ Antifragility- A former quant discusses the nature of risk in these controversial and philosophical books. Some parts of this book are actually called out and shamed in McDonald's Derivative Markets, one or the both of them are worth reading

https://www.amazon.com/Black-Swan-Improbable-Robustness-Fragility/dp/081297381X/ref=sr_1_1?s=books&ie=UTF8&qid=1475105478&sr=1-1&keywords=black+swan



Godel, Escher, Bach- Very dense look into recursive patterns in mathematics and the arts. While not actuarial, it's obviously very mathematical, a must read.

https://www.amazon.com/G%C3%B6del-Escher-Bach-Eternal-Golden/dp/0465026567/ref=sr_1_1?s=books&ie=UTF8&qid=1475105497&sr=1-1&keywords=geb

Endurance- This was recommended to me by a pure mathematics professor. Again, not actuarial, but more about the nature of perseverance though problem solving(sound familiar). It's about Shakleton's famous voyage to the south pole.

https://www.amazon.com/Endurance-Shackletons-Incredible-Alfred-Lansing/dp/0465062881/ref=sr_1_1?s=books&ie=UTF8&qid=1475105520&sr=1-1&keywords=endurance+shackleton%27s+incredible+voyage

u/tspike · 8 pointsr/programming
u/Lord_Illidan · 8 pointsr/compsci

You will want this book sooner rather than later too.
CLRS - Introduction to Algorithms

u/TransFattyAcid · 8 pointsr/webdev

The agile principles are based around the idea of iterative development. This invites what you're calling rework to make the product the best it can be.

Obviously, you're coming at this from a place of frustration because you want to meet deadlines but the "simple" solution is to build all these steps into your estimates. If you're not setting the deadlines, then you need to be up front with your manager about what you can get done in the given time. Maybe it'll work, but not be clean code (the P.S. here is that after it ships, you need time to make it clean). Maybe you can get features X and Y done, but not Z.

Refactoring and code reviews are part of the job. Yes, your manager is going to make suggestions you might not agree with and, yes, the senior devs are going to send you back to the drawing board sometimes. Sometimes it's because they're jerks and sometimes it's because experience has taught them something.

All in all, I'd recommend reading any of the following by Robert Martin. Clean Coder is perhaps most relevant to estimates and deadlines but they're all really helpful.

u/herpington · 8 pointsr/learnprogramming

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.

u/enteleform · 8 pointsr/compsci

I've been coding for a few years and for a while was just focused on getting things to work.  Now I'm at a point where I know I'll figure out any given problem with my accumulated knowledge and/or additional research, and I'm noticing that not planning ahead is the most significant (lack of) action that will set me back at this stage in my practice.

 
To remedy this, I've been looking into architectural patterns (MVC, MVP, MVVM, etc.), and UML diagramming.
 

-----

 
Architectural patterns were initially difficult to grasp, as many of the explanations available online dig into topics that might not make sense yet if you are inexperienced with architecture.  The MVC Java Tutorial by Derek Banas is the best introductory explanation of architectural patterns that I've come across (he also has some great videos on design patterns & other topics).
 
Some books that cover code structure & architecture in more detail:

  • Clean Code: A Handbook of Agile Software Craftsmanship

  • Code Complete: A Practical Handbook of Software Construction

     
    The author of Clean Code, Bob Martin, has a ton of talks that are a great source of info, and has also produced the CleanCoders series.
     

    -----

     
    Also check out some Software UML Examples.  I find that mapping out an overhead view of your project before starting to code gives you a chance to make sure the majority of relationships, life-cycles, and high-level details are planned out correctly from the start.  You'll still have to make inevitable adjustments while coding, but it's much more efficient than figuring it all out from the inside while you're building it.
     
    yEd Graph Editor is a good freeware option for creating UML diagrams.
     
    If you find that you really like the UML approach, check out Enterprise Architect.  It's definitely worth picking up since it allows you to generate file structures from your UML diagrams, with all of the boilerplate filled out already (class/method/variable definitions, etc.).
     

    -----

     
    Also related, SourceMaking has some good wikis on:

  • Design Patterns

  • Refactoring

  • Anti-Patterns

  • UML

     
    (Although their UML material is pretty in-depth and may be overkill if you just want to use UML as a quick way to plan out code.  But it's legit if you want to go all-out UML mode)
u/Centinul · 8 pointsr/java

I agree that Code Complete is an excellent book. Another I'd add to the list is The Pragmatic Programmer.

Effective Java is good but it's really about the nuances of the Java language. It looks like you are looking for better programming practices in general. If so I'd go with the books already mentioned.

u/azimuth · 8 pointsr/compsci

Also Code: The Hidden Language of Computer Hardware and Software. It literally starts out with telegraphs, and shows how, if you are sufficiently crazy, they can be assembled into a working computer. Then it shows how you can write software for your telegraph-relay-cpu. A great read.

u/Adoro_Te_Devote · 8 pointsr/sysadmin

You need to start reading. I don't even know where you should start..maybe here would be best: http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668

u/unacceptablePenguin · 8 pointsr/UniversityOfHouston

Introduction to Algorithms, 3rd Edition (MIT Press) https://www.amazon.com/dp/0262033844/ref=cm_sw_r_cp_apa_89sSAbDN1RQ5V

That's probably the best book for data structures and algorithms out there. It's somewhat pricey but I use it all the time even for work things. You can probably find a free PDF with some digging. Look at the chapters in the Data Structures section particularly the elementary structure and hash map. The trees aren't covered in this course I believe.

u/drjeats · 8 pointsr/gamedev

C++ Primer is one of the usual go-to books for beginners.

[EDIT] Thank you /u/xgalaxy for pointing out I had linked the wrong one. Get this one: http://www.amazon.com/Primer-5th-Edition-Stanley-Lippman/dp/0321714113

u/MrPhantomZz · 8 pointsr/6thForm

Could read a book based on your interests in computer science, e.g. AI, Machine Learning, data science etc.

A good book that I recently picked up was
[Code: The Hidden Language of Computer Hardware and Software by Charles Petzold] (https://www.amazon.co.uk/dp/0735611319/ref=cm_sw_r_cp_api_qB4TBbG90ANHN)

u/lmouelle · 8 pointsr/learnprogramming

Clean code. read it learn it love it

u/sick_anon · 8 pointsr/algorithms

I suggest you to not waste too much time reading 15 different books on algorithms or spreading on 15 different resources (YT videos, online courses, forums, tutorials, etc.). Stick to 1 or 2 good books (try Introduction to Algorithms and, if you're completely new to algorithms, and have no idea what are they and what is their role in computer science and science in general, I recommend book by same author that could make a good preparation to previous book; it's called Algorithms Unlocked ) and start applying that knowledge in the run (solving problems). Remember: don't waste time on hundreds of resources; they may be great and offer some really high quality information about topic, but you just don't have time to go through all of them. Good luck!

u/leeeroyjenkins · 8 pointsr/cscareerquestions

http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844

I won't directly link to a PDF version of it, but it's out there...

u/lightforce3 · 8 pointsr/tech

What you seem to be asking is "how do computers work?" At any rate, the interaction of hardware and software is fundamental to any computer system, whether it's your fitness band or your cell phone or a supercomputer or the computer in your car engine or The Next Big Thing.

How that works is a really, really big question. Rather than attempt to answer it, I'll suggest you check out the book Code by Charles Petzold. It explains how computer hardware and software work, starting with basic electrical circuits and building up layer by layer until you're running an operating system and application software. That might seem like a lot to cover, but Code does it simply and cleanly, in a way that just about anybody can digest and understand.

u/Architarious · 8 pointsr/web_design

You'd probably have better luck with this at /r/design_critiques

But, for now, there's a ton of spacing issues and bugs that come up when going between different viewports. (you're primary navigation only shows the first two links at mobile size) Also, your social media icons at the bottom appear to be skewed and could use more padding. If I was you I would go back and redesign for mobile-first. Maybe even look into using bootstrap

As far as basic visuals go, You're going a little heavy on all the jquery and animations. It's hard to focus on any one thing cause there's so many different things poping and bouncing around everywhere. In that respect it almost puts me in the mind of a geocities website(no-offense). Just because you can animate something doesn't mean you should.

Also, you have to click on the icons or arrows in order to read them. And whenever you do, there's no active state on the icons(or any navigational items) to tell me which subject the information is relating to. In web design, un-seen information is always un-read information. Not to mention that I have to scroll past the content to click on the icons (or secondary navigation).

This site doesn't have a ton of content, but for some reason it feels like there's no negative space. I'd say this is mostly due to the fact that your using so much grey. Since there's no real contrast between anything, there's no real negative space. Try making your background color white or super light grey like (#efefef) and see how that looks. This will also help you out accessibility wise, because people with astigmatisms sometimes have problems with contrast may not be able to read your main content at the current moment, no matter what it's size is.

You also want to look at how your currently using your colors and imagery. You need to step back and ask yourself what the functional purpose of everything that is taking up real-estate on the screen. Generally, when people only use one color like orange in a monotone grey pallet, they're utilizing it as an ambient signifier for a call to action (think about how colors change from station to station when you're on a subway). You want to use that color to tell people to "click here!" or "look at this and do something now!". Right now it draws my eye to the name and a selling point, but I have no idea what to do afterword. For reference, check out how these sites are using their accent colors: http://www.awwwards.com/websites/minimal/

TL:DR; In short, there's a ton of web and usability standards along with design principles that you're overlooking. I would advise getting a book like Steve Krug's - Don't Make Me Think and studying it. It's short and fast read and it will save you mountains of time, frustration, and wasted effort. Also, be sure to review that AWWARDS.com link above. Make a list of what you think they're doing right and what they're doing wrong.

Sorry, I hope that wasn't too harsh, I'm just trying to help and sometimes honesty can be brutal.

u/complich8 · 8 pointsr/AskComputerScience

I don't think you'll find just one -- computer science is too broad, even in the scope of what you're asking for.

You can probably find a reasonably readable algorithms book that'll introduce things like Big-O, Big-theta, Big-omega, graphs, trees, etc. Some of that bleeds into the "data structures" topic area (and vice-versa). This one is highly-regarded, but I couldn't say whether it's "for you" or not -- it's a bit textbooky.

u/wrouzhul · 8 pointsr/learnprogramming

Ooooh you're a super new :)

Many people hate it but w3schools can get you started:

u/kyleaisho · 8 pointsr/learnprogramming

The goldilocks zone is needing 0 comments in order to easily read your code. Chose variable names and function names which are so obvious they don't need comments. However you'll eventually need comments as well, so a simple terse comment that describes only exactly what is being done is beneficial.

When you get enough programming under your belt check out this book:
http://www.amazon.ca/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

u/ezekg · 8 pointsr/webdev

Before becoming a developer, I was running a part-time freelance design studio while working at a coffee shop for a few years. That worked out well for where I was at in my life, but I always wanted to move towards working in an agency to get more experience.

I ended up applying for a few designer positions at small local agencies, and finally got an interview... even if it ended up being a job opening for a front-end developer, not a designer (the job posting wasn't very clear).

Although they would have liked to hire me as a designer, they just didn't have the need. They said they would hire me if I learned HTML, CSS and a little JavsScript to do some front-end templating and design. And so it begun.

I bought a couple books and crammed in some late nights learning how to make a simple website. Learning JavaScript (basically how to use jQuery) was probably the most rewarding part of that. A few months later, I came back to go over what I learned and landed the job as a front end developer and designer. I started out at around $20,000.

Fast forward to where I am now, I am the lead developer for a small agency. I held onto that drive I had in the beginning to delve deeper in computer science via MIT's OpenCourseWare on YouTube. Within just a couple years, I've more than tripled my salary, and pushed myself to areas I'd never thought I'd be able to go (or even be interested in going).

I still do a little bit of design, but I found that my real passion is in development and I plan to continue growing my skillset.

I hope this at least encourages somebody to pursue their career in development. If you can't land a job now, just continue learning until you do land that job. I had to wait nearly 6 months before I finally got that second interview, and it changed my career (and really, my entire life). There's a plethora of courses online at sites like Treehouse and of course YouTube.

Good luck!

u/prodigalOne · 7 pointsr/pics

Whatever I need to stay relevant or updated. At this time I'm taking VMware cert courses from Stanly college, just to stay ahead on my own time. If you're just starting out, take Network+ to understand that realm, but there are a lot of routes you can go in. I always carry around these books though:

The Practice of Network and System Administration

Time Management for System Administrators

u/Salyangoz · 7 pointsr/Turkey

ilk olarak kolay gelsin.

Stanford ve MIT'in online course'lari var itunes university'de ordan bakmaya basla istersen.

Internetten egitimini sevdigin okullarin syllabus'unu alip ordaki kitaplardan calismaya baslayabilirsin zaman kaybetmemek icin. Istersen sana sirali kendi transcriptimdeki dersleri PM olarak atabilirim.

Okulundan aldigin .edu emailini cogu programi bedava kullanmak icin kullanabilirsin. (github inanilmaz bi pack veriyor, %100 suistimal etmeni tavsiye ederim)

Kitap oku ve bol bol kod yaz. Boktan olsa, bozuk olsa bile yaz. Kagit kalemle de yazmaya cekinme (is basvurularinda seni beyaz tahtaya cikaracaklar malesef debugger/syntax checker olmicak)

aklima gelen standart kitaplardan en onde su geliyor:

  • Introduction to algorithms : facebook ve google direk bu kitap icinden soru soruyor ise alimlarda. Cogu ilk basta cok zor gelebilir, korkuya gerek yok, 2 sayfayi 3 gunde falan yapiyorsan cok iyi.


  • Bilgisayar temel bilgileri icin de Computer Organization

    Eger lise bilgilerinden korkuyorsan cok inanilmaz bi matematik yok (sektorune gore degisebilir tabi). Lineer Cebir (image processing/game-development vs.) ve Olasilik (AI, Machine learning, data analysis vs.) bilgilerini tazele. Eger machine learning falan yapmak istiyorsan ilerde olasilik bilginin guclu olmasi gerek.

    Cok net bi cizgi izlemene gerek yok. Gerektikce ogrenme politikasi benden yana cikti su ana kadar ama bu tartisilir.

    baska bisi olursa cevap vermeye calisirim.
u/sorryateyourbagel · 7 pointsr/ECE

I have a EE undergrad degree and work as a software developer (mostly web development).

Best advice is to code as much as possible. I second @jewdai's recommendation to study data structures and algorithms -> learning these will give you a solid toolset for solving problems (w/ code) in the future. The bible for data structures and algorithms is:
https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=zg_bs_132570011_2?_encoding=UTF8&psc=1&refRID=G4V554CGYNTY1J7NT6AZ

You should investigate what type of industry you're interested in. If you're interested in signal processing, check out companies that specialize in that area (I guarantee they need software developers).

Best chance for getting an entry level position would be one where you can leverage your EE expertise, but spend most of your time programming (it's the only way to get better). Working on an embedded system (e.g. firmware) might be a good fit because you need solid EE knowledge as well as software skills.

I would also leverage my alumni network; talk to your classmates fellow grads who are in software now. Get their advice and network; those connections can lead to jobs (or at least interviews at their companies).

Best of luck!

u/dzjay · 7 pointsr/learnprogramming

Check the syllabus and get a head start on the topics covered. My two favorite C books are C Programming: A Modern Approach and C Programming Language. The first one is for absolute beginners, while the second one is for someone who already knows the basics of programming.

u/myevillaugh · 7 pointsr/opengl

I suggest disconnecting the two. You need to have a firm grasp on C or C++ programming before going into graphics. It's a long road, but worth it.

This book is considered the authoritative source on C programming, written by the creator: http://www.amazon.com/C-Programming-Language-2nd-Edition/dp/0131103628

Here are some text based tutorials that I used to learn OpenGL recently.

http://openglbook.com/the-book/

http://www.swiftless.com/tutorials/opengl4/1-opengl-window.html

http://en.wikibooks.org/wiki/OpenGL_Programming

Good luck!

u/lsd503 · 7 pointsr/compsci

Code Complete by Steve McConnell

u/schreiberbj · 7 pointsr/UIUC
  1. Start looking at basic programming, specifically in C. There are a lot of good tutorials and books. I like this one.

  2. Your first year, the hardest class will be ECE 220 in the Spring. The hardest overall are ECE 385, 391, and 411, and CS 374. Don't worry about those yet.

  3. Look at scheedule for scheduling. Be sure to take ECE 120 in the Fall. The rest of your schedule doesn't really matter. It will probably be calc, chem, and rhet.

  4. Breathe.

  5. Yes. Plenty of engineers party.

  6. Study, especially in a group. Everyone is in the same boat, so learn to work together.
u/autophage · 7 pointsr/IWantToLearn

Speaking as someone who was great at reading but bad at retaining, learned to retain while in college getting a liberal arts degree, and has been reasonably successful at teaching himself programming languages since graduating...

Read things twice. Not necessarily the whole book, but for each paragraph you come across, think about what it's saying. If it is introducing something new, then read it a second time.

Read things out loud. Not even stuff you're trying to learn, and not necessarily to an audience. But (if you're taking my advice about reading things twice) do your second go-through out loud. You'll find that often your intonation is wrong - you didn't catch that something was a question, or you thought you were on the last clause of a sentence but you were wrong. Dedicate some small part of your brain to listening as you read out loud, and fixing these problems. This will help you get the structure of a thing - which parts are introductory, cursory, or parenthetical, and thus can be skipped over; which parts are REALLY IMPORTANT, which parts are actually pretty damn funny but you missed the joke the first time...

Don't just read. Explain to people what you're reading. My housemates and girlfriend have probably sponged half the stuff I've taught myself (about programming, musical instruments, bicycles, pretty much anything I've decided to learn about) because I'm constantly asking if they mind if I explain a concept to them. It helps that we're all young, intelligent, curious people.

Have a conversation with the book. When you come across something that seems wrong, don't just plow through - see if you can figure out why it just said what it did. Maybe you read it wrong. Maybe you misunderstood an earlier concept. Maybe you thought the dude was speaking when it was the lady. The point is that after that initial moment of confusion, you'll have a moment when it Suddenly Makes Sense - cultivate your enjoyment of that moment. It's one of the greatest pleasures of reading.

Do the stuff you're reading about. In the case of programming, do the exercises. If you're reading a book about a foreign language, acclimate yourself to the rules of pronunciation. In a work of fiction, hand the part of you that experiences emotions over to the author and let him or her shove you around to whatever he or she wants. If there's a math concept that doesn't quite make sense, pull it up on Wikipedia and read the links that describe any of the fundamental elements that you're missing.

If you want to get into programming, read one of the Head First books. They talk a lot about effective ways to learn things, in addition to putting those principles into practice in how they teach programming. This book started me on my current routine of reading a chapter of (whatever computer book, currently Code Complete) when I first wake up in the morning.

Apologies for the wall of text, I hope that was helpful. I'll edit to add anything that I think of.

u/chonglibloodsport · 7 pointsr/technology

If you're looking to learn C, get K&R.

u/ballsonmywalls · 7 pointsr/learnprogramming

The official tutorials are not bad:
http://download.oracle.com/javase/tutorial/
I also recommend Head First Java as a book:
http://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208

u/sionide21 · 7 pointsr/ProgrammerHumor
u/Kuytu · 7 pointsr/programming

[Code Complete] ( http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670) 960 pages, no fluff, essential reading to any programmer.

u/yoho139 · 7 pointsr/ProgrammerHumor

From wikipedia, and I highly recommend this book as reference material.

u/PsychedelicFrontier · 7 pointsr/RationalPsychonaut

What a great question, and an interesting example. For those confused by OP's example, check out Gödel's Incompleteness Theorem on Wiki. Better yet, read the insightful and very trippy Pulitzer Prize winning book, Gödel, Escher, Bach. Gödel's theorem is a bit abstract but it was both a monumental and surprising discovery. It's not just mathematical -- it's meta-mathematical, in that it reveals the limitations inherent to any mathematical framework or system. From wiki:

>The first incompleteness theorem states that no consistent system of axioms...is capable of proving all truths about the relations of the natural numbers (arithmetic). For any such system, there will always be statements about the natural numbers that are true, but that are unprovable within the system. The second incompleteness theorem, an extension of the first, shows that such a system cannot demonstrate its own consistency.

I'll point out an obvious one, though it's more to do with the aesthetics of the psychedelic experience rather than insights or ideas. Psychedelic hallucinations tend to be geometric, with lattices, grids, spirals, and perhaps most intriguing of all, fractals. All these are geometric forms that can be rigorously defined and analyzed by math. Fractals are especially fascinating because they exhibit self-similarity at every scale, appear sometimes in nature (for example, coastlines), and look extremely trippy. (Seriously, just look at these zoom-ins of the Mandelbrot set, discovered in 1978.)

u/SADISTICBLUE · 7 pointsr/Malware

+1 for mentioning malwareunicorns Reverse Engineering Malware 101 course. I'm pretty excited about starting that after I'm done with some Powershell stuff.

Books for: /u/Kreator333 and /u/curiousdoggo

C/C++:

  • The C Programming Language (2nd Edition) - K&R is fine for fundementals.

  • Pointers on C the sections on pointers are phenomenal. The author explains them in great depth with lots of examples.

  • TBH I haven't learned C++ yet but this definitive guide/list looks promising.

    Assembly/C:

  • Hacking The Art of Exploitation 2nd Edition. Mainly the chapter on programming which pretty much has everything you need. It can get you started with C and ASM and how they compare by stepping through examples using GDB, etc.. Read this if you really want to hit the ground running and then jump into those other books you mentioned OP.

    Also OP while your learning the basics here do as many examples as you can. Don't just read it and assume you know everything. For C you can try coding a bunch of classical ciphers and for ASM, debug the assembly of simple programs in gdb. (check out godbolt) or try coding a echo client/server in Nasm.
u/pdoherty926 · 7 pointsr/C_Programming

I haven't read either of those, but I did enjoy and find a lot of value in K&R and 21st Century C.

u/deiphiz · 7 pointsr/learnprogramming

Okay, I'm gonna plug this in here. I hope this doesn't get buried because when I saw someone asking about low level stuff here, I couldn't help but make this recommendation.

For anyone that wants to learn more about low level computer stuff such as assembly code should read the book Code: The Hidden Language of Computer Hardware and Software by Charles Petzold. I've been reading it recently and I'm really glad I picked it up. It really delves into how a computer really works, like how languages relate to the circuits on a board.

So yeah, /u/DEVi4TION, I recommend picking this up if you wanna know about more stuff like this. Then maybe try your hand at actual 6502 programming later :P

u/both-shoes-off · 7 pointsr/csharp

Google "c# github projects for beginners". Theres a whole bunch of interesting stuff out there. You could also download/fork a github repo and try to extend a project, or build on top of it.

I think this repo has been posted here before, but learning design patterns is really useful prior to designing something from ground up. https://github.com/Finickyflame/DesignPatterns

Here's a good beginner's book on design patterns. https://www.amazon.com/dp/0596007124/ref=cm_sw_r_cp_apa_i_FmHsDbGWQ0NTJ

u/alphaglosined · 7 pointsr/csharp

I would recommend not looking for C# specific books. Language specific books tend to get out-dated very fast and won't be as high of quality.


For this reason you want books like https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 and https://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043

​

I'm personally in the market for data structure books, sadly its a slippery slope when you already have a few.

u/zjs · 7 pointsr/web_design

It's not quite what you asked for, but the parent of this reply answers that.

JavaScript: The Good Parts offers a wonderful Computer Science style discussion of JavaScript.

u/Tefferi · 7 pointsr/JobFair

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

u/TheIndoIrishman · 7 pointsr/ireland

Any book on technology. Like this one. Oh yes, most Indians wanting out are settled in the US or the UK or Australia nowadays. I'm mostly a lurker here and on reddit. I don't understand most of the posts, especially the ones on politics, although I'm learning new terms like Dail and Taoiseach and I'm pretty sure I don't know how to pronounce these words. I'm trying to participate in self posts like these.

u/justanothercactus · 7 pointsr/DesignPorn

You might like this [book] (https://www.amazon.com/G%C3%B6del-Escher-Bach-Eternal-Golden/dp/0465026567)...Gödel, Escher, Bach: An Eternal Golden Braid, the cover has an even better whatever you call that effect/illusion.

u/pureofpure · 7 pointsr/cpp

C++ Primer (5th Edition) it's good to start https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113/ref=sr_1_1?ie=UTF8&qid=1496834580&sr=8-1&keywords=c+primer

Try to avoid books like "for Dummies" or "Teach Yourself".

u/ForeverAlot · 7 pointsr/cpp

There are more bad sources of learning C++ on the Internet than there are good ones. I am not familiar with LearnCpp.com but looking at just a handful of its chapters it is misleading, out of date, violates a number of C++ idioms, and focused on the wrong things wrt. learning C++ specifically.

C++ Primer 5th ed. is a very good book for getting started with modern C++.

u/Wiggledan · 7 pointsr/C_Programming

I've been self-teaching myself C through various books/courses/series the last few months (I'm still not that great), and so I have some suggestions about good places to start learning.

Books:

  • The C Programming Language AKA "K&R" by developers of C - It's short/concise and simple, but covers the whole language (because there's not that much syntax to cover), and tons of people swear by it like a bible.
  • C Programming: A Modern Approach by K. N. King - This book is much larger and more in depth than K&R, with around 800 pages and lots of examples and exercises. It's essentially a college textbook and is actually used in colleges.
  • Learn C the Hard Way by Zed Shaw - This one is free and online. I like it because it focuses more on you figuring out things on your own by breaking the code in various ways and having an absolute understanding of every line, rather than just having you copy everything and telling you how it works

    Courses/Videos:

  • [Harvard CS50x](https://www.edx.org/course/introduction-computer-science-harvardx-cs50x) - An awesome, free online course with high production lectures, and helpful videos/tips if you get stuck. It mostly covers C, but it does go into other things (that are still worth knowing) at the very beginning and end.

  • A Free Course for C Beginners by Carl Herold - Not really a full course, just most of the videos. I found this very recently, and the original website doesn't exist anymore. It goes at a very relaxed pace and explains things incredibly well in a way that you will remember. These videos really solidified/helped my understanding of binary, hex, and pointers. I highly, highly recommend it over anything else if you're just starting out.
  • Handmade Hero by Casey Muratori - You can watch and follow along with this guy as he programs a video game from scratch in C. He streams every weekday, usually has a Q&A after, and puts every video up on YouTube. The series starts off with a sort of rushed intro to C, and honestly the whole thing is always at a fast pace and can feel complicated. But that's what it takes to make a game from scratch, and he takes time to explain what everything means. Plus it's mostly all very interesting and useful.

    Resources:

  • Google - google everything, or Bing it, I don't care
  • Stackoverflow - someone probably asked your question before, especially with C
  • /r/dailyprogrammer - Great daily challenges. These are like working out your programming muscles.
  • /r/learnprogramming - Occasional posts about C, and you can ask/find your questions here as well
  • Online C Compiler - A convenient compiler that you can use anywhere to play with simple programs using C standard library functions.

    Other than that, you should maybe look into trying out Linux, because it's more developer-friendly than Windows (such as having a C compiler out of the box). And the whole kernel and many core components of the OS are written in C, which are all usually open source, so you can learn from, and contribute to them.

    Good luck, friend.
u/ironmaiden947 · 7 pointsr/learnprogramming

The C Programming Language by K&R is probably the first book people recommend.

Learn C The Hard Way is more hands-on, but if you already know other programming languages youll be fine.

I dont know about any interactive courses, but HackerRank has lots of challanges you can solve in a multitude of languages (including C) which is pretty close to CodeAcademy. Keep in mind that it gets hard pretty quick, so it is better to be somewhat comfortable with your chosen language before doing them.

u/Adenverd · 7 pointsr/programming

Preface: I'm not being condescending, I know a lot of incredible programmers who never attended a computer science class.

To be honest, this is the sort of stuff you learn about in a computer science degree program (though this would probably fit better in a graduate degree than an undergrad). If it really interests you, you should look into it.

If that's not a really viable option, I can't recommend this book on algorithms highly enough. It talks about runtime, scaling, data structures and graphs, etc. Truly fascinating stuff.

u/crwcomposer · 7 pointsr/compsci

His algorithms class probably used this textbook, but if they didn't, it's pretty much a standard:

http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844

Don't be deceived by the title, it's more than just an introduction. As the description on Amazon states:

>Some books on algorithms are rigorous but incomplete; others cover masses of material but lack rigor. Introduction to Algorithms uniquely combines rigor and comprehensiveness.

u/BeechTreeLLC · 7 pointsr/sysadmin

I also recommend this book:


"The Practice of System and Network Administration"
by Thomas A. Limoncelli

http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668

u/InvalidGuest · 7 pointsr/computerscience

I'd recommend this one: https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

It's very enjoyable to read and definitely increases one's understanding of how computer conceptually function. Petzold also makes it very easy to understand what he is saying in his explanations.

u/alex_kendall · 7 pointsr/compsci

The Mythical Man Month published 1975(!)

"Arguably the only classic book in our field"
----------------
Lot of good books listed here, but my advice is to read this book, and play around with some new tool (like git). Now that I think about it, learning git along with reading this book is actually perfect, because you'll learn how to use the tools that we have today that the author dreams of, and why they are so powerful and important.

Yes, this is the perfect break material: git and The Mythical Man Month. Short book too.

u/FuRy2k · 7 pointsr/sysadmin

Pick up The Practice of System and Network Administration. It's OS agnostic, so you'll still need to research into other OS specific areas, but I found it was a great starting place for fundamentals.

u/crankysysadmin · 7 pointsr/sysadmin

You're probably better than you think. Also, you're actually in a better spot than people who get comfortable with their little environment and think they're really great. There's no way you can improve someone who thinks he is amazing at what he does.

Rather than give up on IT, try to find a place where you can work that pushes you harder and forces you to learn new things.

Go read this book:

http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668

What makes someone a good sysadmin isn't knowing everything about everything (you can't) but instead developing really good methods and processes for getting work done.

u/chhhyeahtone · 7 pointsr/learnprogramming

If you want to know what programming is like, try Stanford's CS101 course. It's very basic but gives you a taste of what you can learn. You can breeze through it in a week or two. Don't worry about memorizing the code, just focus on the concepts.

If you finish that and enjoyed it, you can try M.I.T's 6.00 1 course. It teaches you Python, one of the easier programming languages to start with. This course is longer than the first one and is an actual programming course. It recommends the book Introduction to Computation and Programming Using Python if you need it.

After that, I would say give Harvard's CS50 online course a go. This course teaches you the C language and is easier to complete if you did the first two courses. This course recommends the books: The C programming language book or C programming: an absolute beginners guide for a more beginner friendly (and budget friendly) option.

Good luck and have fun

u/ZukoBestGirl · 7 pointsr/ProgrammerHumor

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 programming over how 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.

u/sideh · 7 pointsr/sysadmin

This: http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668

I wish I'd read it at the start of my career.

Other than than, learn the fundamentals well and you'll be fine.

u/brettmjohnson · 7 pointsr/AskComputerScience

Pick up a copy of K&R (ANSI edition). It is thin and the definitive reference. You can burn through the exercises pretty quickly, especially if you have used Java, C++, or C#.

Ridiculously-priced hard copy (IIRC, I paid about $20 for my copy.)

E-book PDF

u/emcoffey3 · 7 pointsr/webdev

I'm a big fan of JavaScript: The Good Parts. I'm not sure if it is quite intermediate, but it is a terrific (and short) read.

Secrets of the JavaScript Ninja is a bit more advanced. It's written by the guy who created jQuery. I found some of the coding style to be sort of strange, but it does have a lot of great information.

u/CastleSeven · 7 pointsr/learnprogramming

The C Programming Language is what I'm reading now.

http://www.amazon.com/exec/obidos/ASIN/0131103628/ref=nosim/schmcreadesis-20

u/Neui · 7 pointsr/C_Programming

I would make the logo a blue C, like in the title page of The C Programming Language: https://i.imgur.com/yMpmgEp.png

u/zzyzzyxx · 7 pointsr/learnprogramming

You have semicolons after your if statements. Though I don't see why it's not printing both statements. In fact, I just ran what you have posted and it did print both. Did you mistype something by chance instead of copy/paste?

Your if statements should be something like

if (mrk >= 440) {
// print message
} else {
// print other message
}

Note that there are no braces around the if statements like you have either.

Edit: You should probably get a better resource for Java than a For Dummies book. Head First Java is often recommended. You might try the official Java tutorials as well.

u/bodiam · 7 pointsr/programming

I believe this is a pretty good book for legacy / maintenance systems:

https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052

u/egben · 7 pointsr/science
u/zman0900 · 7 pointsr/cscareerquestions

More than likely, your textbook will be Intro to Algorithms. Find yourself a copy and start reading. Even if the class uses something else, it's a great reference to have around.

u/hga_another · 7 pointsr/KotakuInAction

In all fairness to him, it was when you showed enough merit in your work.

And one can make a great deal of progress in 4 years of real world software development. But by the language of highly recommended The Pragmatic Programmer: From Journeyman to Master, you were almost certainly still a journeyman back then. I would guess it took me > 10 man years to obtain mastery.

u/lordnikkon · 7 pointsr/cscareerquestions

This is a great book for computer fundamentals that you should just read if you have any interest in computer science. But realistically you will not use much from this book in the real world. It is something to read to understand how things work.

You will get a lot more useful things out of a book like Intro to algorithms than SICP. The biggest thing i find self taught devs lack is an understanding of data structures. They know how to code and write solutions but dont know which data structure is efficient or why. They may learn by trial an error that one data structure is better for certain task but dont know why. If you are able to understand how the standard collections library for most major languages work you will be ahead of most devs

u/gerundpu · 7 pointsr/philosophy

Yes, and if you want to follow this deeper into the context of consciousness, check out this book: GEB

There's a series of chapters discussing the localization of brain functions. The author discusses a study on rat brains, in which maze-running rats had significant portions of their brains removed, and were allowed to heal. Most rats were still able to re-learn the maze.

u/carols10cents · 7 pointsr/cscareerquestions

I highly recommend the book Working Effectively with Legacy Code by Michael Feathers. It has a bunch of practical tips for just this situation.

u/b_bellomo · 7 pointsr/learnjava

I don't know what is that book's style but these free programming books/courses will strengthen your knowledge of the basics and introduce you to more complex stuff :

u/Scarface74 · 7 pointsr/cscareerquestions

Yes. But it’s a great paying skill. There are techniques for working with legacy code.

This is the go to book for it.
https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052

u/juliob · 7 pointsr/Python

Can I offer some food for thought?

On Clean Code, Robert C Martim said that functions should have, at most, 5 parameters. After that, it's a mess.

You should probably look into ways of reducing the number of parameters. Maybe 3 or 5 of those are related to a single object, with related functions.

Just a suggestion.

PS: Also, I think you'll get a Pylint error about too many instance variables, or something like that.

u/rockyrainy · 7 pointsr/cscareerquestions

I am not a great coder, but I had to deal with this bs in the past.

Find where the data structures are, figure out the layout then focus on the transformation. Legacy code usually has some core logic (10%) and a whole bunch of one off hacks bolted on (90%).

Buy this book.
http://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052

Financially plan for getting fired tomorrow. Save money, don't get locked into long term rental/mortgage. Reduce your debt burden if you have one.

u/Butter_sc0tch · 7 pointsr/learnprogramming


Senior dev here who is on the other side of things. One way to approach these situations is to try and approach the problem more from the business case. I’m not sure of your work culture, but you should be bought in as to why a deliverable is time sensitive and what there is to gain by delivering this week vs a week or two later. If people don’t have reasons, they need to be held more accountable for the longer term delivery. Tech debt is a slow killer. You’d be surprised with how much you can push back:
How is this feature being measured?
What is success criteria?
What are the next steps if successful? If unsuccessful?
What are we not doing in order to do this task? Is this the most impactful thing we can spend our time on?

Also, understand that any system is due for a rewrite every 4 years or so. No matter how clean you write, you’ll eventually have to refactor anyway. You defiantly want to maintain something workable, but keep in mind there is no such thing as a permanent solution.

And finally, Great book ok how to make small iterative improvements as you go.
Working Effectively with Legacy Code https://www.amazon.ca/dp/0131177052/ref=cm_sw_r_cp_api_i_Td0QDbFQKYV3T

u/Gankbanger · 7 pointsr/learnprogramming

These are the coding conventions every Java developer should follow:
Oracle's Code Conventions for the Java Programming Language

If there are industry-wide coding conventions for the particular language, follow those. (i.e.: Java , C#); otherwise, most companies will enforce some conventions (i.e. most companies have their own C++, C coding conventions); otherwise, establish some, and stick to it. This book has general guidelines on coding conventions and best practices: Code Complete 2

u/mrcleaver · 7 pointsr/java

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.

u/dakboy · 7 pointsr/programming

LWRellim is exactly right.

Tomorrow morning, go to your local library or bookstore and find this book. You don't have to read the whole thing right away, but if you can spend the afternoon with it at least, it's worthwhile.

Chapter 11 especially is appropriate here, where you're in the position of "flushing it all down the proverbial crapper." Plan to Throw One Away One can also use a line from The Matrix - everyone falls the first time.

I'm not going to say that every software project bombs the first time around. That's definitely not the case. But many times, especially on your first custom programming experience, no matter how well you think you understand what needs to be built, you will paint yourself into corners and discover all kinds of stuff that you had never considered before you started to build the first version.

Depending on where you are in the project, and how things have been put together, you may have to literally toss everything. In your case, you might be able to salvage some UI bits, but your new developer will probably redo everything else.

u/Zweifuss · 7 pointsr/cpp

C++ Primer (https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113/) as /u/sempuki mentioned.

It's clearly written and is really good at teaching you modern c++ concepts and conventions, while many other c++ books are actually "program c using c++" books.

u/DevIceMan · 7 pointsr/cscareerquestions

> there is no documentation

Documentation typically, at best, describes only what the original author originally intended, and as you noticed, can become quickly obsolete.

Instead, another approach is to write cleaner "self documenting" code, which includes several concepts such as meaningful/descriptive names, single purpose principle, and several others. If you are interested in these concepts, I highly recommend "Clean Code" by Robert Martin.

> 30+ character length method names

Long names are not always always terrible; the more important question is are the names meaningful and descriptive? I recently worked at a place, where class and method names were of similar length to what you describe, and was originally extremely annoyed at the length. After reading the previously mentioned book, I was no longer annoyed at the length, but realized what bothered me the most was that the names were terrible and confusing, the code was poorly formatted, and the names had to be long because of excessive violation of single purpose principle.

Long names can make code easier or more difficult to read. Again, read Clean Code, and you'll have a better understanding and be able to better articulate what is wrong (and perhaps even fix it).

> There's water cooler talk about a method that's over 2,000 lines long.

Definitely a code-smell. My guess is the 130-char name, and 2000 line method violate single purpose principle quite heavily.

> My job: dead code removal.

Entry/Intern level jobs tend to be mundane grunt work that no one else wants to do. I'm not saying that to make you feel better, but rather so that you'll understand "why."

> When we do our daily scrum nobody even understands what I'm doing

Is your team almost purely interns?

> All our tests are broken now. All of them. Production is halted. Why? An execution script needed to have a flag added to it, the commit was made from a Windows machine, and now it's sitting on the trunk of our repo being deployed to all of our testing environments.

Code review and testing failure, especially given you're an intern. Your next paragraph seems to indicate your interaction with the "thing" somehow was part of a process that caused everything to break (though it wasn't specifically you that broke it)?

> What do I do?

5 years from now, it won't matter. The stress you are experiencing is not healthy, and will matter 5 years from now. Relax, stop stressing, the worst they can do is fire you... which is probably not a terrible thing and unless you're hurting financially. Go home on time, work at a consistent pace, and take care of yourself. Polish your resume, and find another company that is more sensible to intern at.

u/TheOssuary · 7 pointsr/PHP

I've been reading Clean Code: A Handbook of Agile Software Craftsmanship and chapter two discusses this, and agrees with you. Interfaces should not be suffixed with 'interface', and if you run into naming issues (wanting to name the interface and the class Product) you should lean towards naming the interface Product and the class ConcreteProduct.

I started following this practice and it makes a lot of sense after you start working this way. If I'm making an interface it means anything which implements it should be valid, so I should never type-hint a concrete implementation, I should only ever type-hint the interface. Adding the Interface suffix is just adding verbosity and possible confusion.

u/FuzzyGamer · 7 pointsr/learnjava

For Android I can recommend the Udacity course. Basically they teach you the building blocks of any Android App by making you build a weather App. It's very... "holdy-handsy" though. Each concept is broken down into manageable chunks (small coding exercises). You get to watch videos explaining the concept then you gotta complete the example programs they provide (It's basically just following some TODOs that are commented in the code), and at the end of the class you have to put it all together and add that to the main weather app.

They won't explain any Java syntax / concepts that they use but if you know some OOP language it won't be too hard to understand what they are doing (though it's gonna be a bit harder to understand why they are doing it the way they do).

Top tip: every exercise is accompanied by a short video where someone will show you how to code everything. My suggestion is to watch the video once to get the basic gist of it then go and code by your own (using the Android Reference if needed). Avoid just copy-pasting what you see in the video. It might seem sluggish and hard but that's how you'll get the most out of it.

As for Java, I don't know any course that teaches it in that manner but I can recommend Oracle's Java Tutorials and Head First Java. Oracle's tutorials are really comprehensive but imo they can get a bit dull, while the book is really fun and easy to follow (and if you know a concept already you can just skim that chapter and move on).

u/trimatt · 7 pointsr/java

If you want to gain a bit of confidence in writing good Java code i'd start by reading Josh Bloch's Effective Java. It's a fantastic reference manual to have on your desk...

Check it out here

u/mstoiber · 7 pointsr/web_design

I'd start learning more about design and design theory.

Start with The Principles of Beautiful Web Design to get an introduction to Web Design, go on to Elements of Style to learn more about typography and finish with Don't make me think and Above The Fold to get started with User Experience.

u/lotion_booger · 7 pointsr/compsci

Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin, amazon link on the [internet] (http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882)

u/planetstarbucks · 7 pointsr/javascript

Buy Clean Code (https://www.amazon.ca/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882). This book is my bible. Read it through once quickly, and refer back to it once in awhile, and I can guarantee you'll never write spaghetti code again.

u/Bayequentist · 7 pointsr/algorithms

You should read CLRS from cover to cover.

u/unknowngp · 7 pointsr/AskComputerScience

>I want to be able to understand how computers work

Code: The Hidden Language of Computer Hardware and Software

I was on the search for the same as you a couple of weeks ago and people recommended the book above. I just recently started reading it but hopefully someone who has read it can chime in with their opinion.

u/HarlequinNight · 7 pointsr/math

You would love Godel Escher Bach by Douglas R Hofstadter. It won the pullitzer prize and is basically just a really good popular math/computer science/art book. But a really excellent jumping off point. Yes it lacks mathematical rigor (of course) but if you are a bright clever person who likes these things, its a must read just for exposure to the inter-connectivity of all of these topics in a very artistic and philosophical way. But be prepared for computer code, musical staff notation, DNA sequences, paintings, and poetry (all themed around Godel, Escher and Bach).

u/DeadZombie9 · 7 pointsr/umanitoba

Books aren't required for first-year CS (they aren't needed for other years either).

Here is the online version of the book they use in COMP 1010. They will give you a link for the COMP 1020 book when you take the course but I'm not gonna look around for it.

General advice for any CS students: A good algorithms book is very handy. I recommend investing in this one. It's gonna be useful throughout your undergrad degree and probably afterward too.

u/shobble · 7 pointsr/books

In Search Of Schrodinger's Cat by John Gribbin is a very readable physics and quantum physics history sketch. Might be slightly dated now, although I can't think of anything directly contradicted by recent work. Then again, I'm not actually a physicist :)

The Quark and the Jaguar is quite a bit more complicated, but still quite accessible to the layperson and has a lot of interesting stuff.

Slightly less sciency, more maths/logic/computation is Gödel, Escher, Bach: An Eternal Golden Braid

A Guinea Pig's History of Biology is pretty much what the title says, although there's an awful lot about fruit-flies too. Quite a good review of the history of biological experimentation, especially genetics.

H2O: A Biography of Water from a previous editor of Nature, covers water across a variety of fields. The second half of the book is mostly a rant about cold fusion and homoeopathy though, from what I recall, but the first half makes up for it.

Most general-audience things by Richard Feynman are well worth the read. He's got some great physics lectures, and his autobiography (Surely You're Joking, Mr Feynman?) is fun, but more for the anecdotes than the science.

Those are off the top of my head. If its something in a particular field, I might have some other ideas I'm currently forgetting.

u/megaicemage · 7 pointsr/learnprogramming

Someone else can probably point you to an actual resource, but here are my two cents.

Data Structures and Algorithms is a topic that you don't pick a specific language to learn in. All of the topics covered in algorithms are applicable to all languages, so it's usually a good idea to have a pretty good knowledge of the inner workings of your language of choice. Given this information, the textbook that my class used and it sounds like many other classes also use is Introduction to algorithms

u/reddit_user_---_---_ · 7 pointsr/webdev

I'm assuming you are looking for generic algo and data struct taught in college:

Look up a university syllabus online, see the name of data structures, learn and implement them in whatever programming language. Same for algorithm, follow some syllebus, learn an algorithm, implement it. For more theory/math pick up a book, follow one of many mooc or find some university course's slides to work with.

I just did a quick search to make sure it is possible to find syllabuses, here's one of them I found for DS: http://bits.usc.edu/cs104/syllabus.html

Here's one for algo: http://www.people.iup.edu/sanwar/COSC%20310%20Syllabus.pdf

For book, my uni used this for DS: https://www.amazon.com/Data-Structures-Other-Objects-Using/dp/0132129485 (good)

For algo: https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844 (overrated, old and confusing, find something better if you can)

u/williamfwm · 7 pointsr/technology

>The next generation of algorithms or smart application of the old ones could create even more upheaval

What, specifically, should we regulate, and how? An algorithm is just a set of steps that produces a correct answer to a problem. Which algorithms do you propose we regulate, and what should the regulations be? Should I go to jail if I implement a C++ solution of the map-coloring problem in a college classroom? Are there whole chapters of the classic CLRS textbook that should be banned from the curriculum?

A vague reference to "the next generation of algorithms" is hand-wavy, and suggests a fundamental misunderstanding of what algorithms are and how they apply to AI.

There is no algorithm that is going to just switch on one day and take over the world. That makes as much sense as worrying that the Pythagorean Theorem will wake up tomorrow and become SkyNet.

u/ArmenShimoon · 7 pointsr/csharp

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:

  1. Design Patterns (Amazon) - also known as the "Gang of Four" Design Patterns, it was originally published in 1994 and is still relevant today. When people talk about design patterns, they're referring to the book more often then not.

  2. Soft Skills (Amazon) - Not a book on programming actually... it's a software developers life manual. The reason I like this book is it covers the other parts of the life of a developer that I haven't seen covered anywhere else. Everything from learning strategies, time management, career advice, and even some health and fitness. It was an enjoyable read and I think other developers would enjoy it too.

  3. The Passionate Programmer (Amazon) It's been a while since I've read this one, but I remember it giving decent advice for building a career in software development. Not to be confused with The Pragmatic Programmer (Amazon) which should be read at some point too.

    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.
u/webdevop · 7 pointsr/webdev
u/SidewaysGate · 7 pointsr/compsci

When I was a young teenager I read (most of) a book called Code.

This was absolutely fantastic. It didn't just talk about programming or about software, it explained the concept of a code and the work that we do from the ground up. It literally started from light bulbs and switches and went to microprocessors and programming languages. This is the book that helped me bridge the software-hardware cognitive gap. Eventually it got to be too much for me, but in my defense I was 12-13 at the time. Even so, the parts that I did get through stuck with me.

I'm going to go back and reread it.

The book isn't going to cover design patterns or microservices, but IMO it's best thing to give computer scientists context on what we're doing here from an engineering perspective (with sipser as the book from the mathematical perspective)

u/Mythiees · 7 pointsr/todayilearned

I don't follow?

At some point we started asking questions about the world. There came a time where 'something' emerged in us and we started questioning the world around us.

Questions are investigations about how the world (and here 'world' is everything in the immediate environment) works. This leads to 'what if' scenarios, equivalencies 'is this thing like the other?' and sets 'I belong to the group called 'men', she belongs to the group called 'women'. In the group called 'women' there is the subset of 'women' that are my offspring. Godel, Escher, Bach yourself on sets and other concepts.

So, we learned how to ask questions and the answers to those questions lead to more questions. All this leads to the internet and us meeting. Our interaction is the result of an unbroken chain of questions that has brought us from the savanna all the way to here. Think about that.

u/theanzelm · 7 pointsr/Games

I can really recommend this book: http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742 (not an affiliate link ;) )

JavaScript is amazing if you embrace it's prototype-orientation and assorted ugly warts.

u/rjett · 6 pointsr/javascript

Advanced

Medium

Old, but probably still relevant

Yet to be released, but you can get the in progress pdf from the publisher

Docs

The one that everybody recommends

HTML5 spec

HTML5Rocks

Latest Webkit News

Other than that build build build. Make demos and play. Ask questions here or on stackoverflow and read other people's code. Also, lots of great old JSConf videos out there.

u/chapmbk · 6 pointsr/java

The most important thing when looking for a Java developer job is to actually understand Java. I don't mean knowing how to write code in Java. I mean knowing how the language works. What is the purpose of equals/hashCode, how to make object Immutable, what is the String pool, etc...
You would be surprised how many developers think they understand the language and have no clue how it works.


  1. Read and understand effective java and clean code.
  2. Be familiar with and excited about automated testing. You should aim for 80% - 90% unit test code coverage in your projects.
  3. Be familiar with static code analysis tools. PMD, FindBugs, etc...
  4. Understand the benefits of code reviews. Be familiar with popular code review tools. Crucible, etc...
  5. Have a degree.
  6. Be familiar with current technologies. Show that you research new technologies on your own

    You do not need all these things to get a job. There are plenty of large IT organizations that will just hire lots of people to fill seats and then drop them if they don't work out. However, if you want to get a job at a company that is serious about producing quality code, you need to show that you are serious about being the best developer you can be. Getting a job at an organization like this will not only pay better but you will also have the opportunity to learn from all the highly skilled developers that work there.
u/Omnipotent0 · 6 pointsr/educationalgifs

This is the best video on the subject I've ever seen. http://youtu.be/VBDoT8o4q00
Of you want to learn more I very very very strongly recommend this book. http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

u/EricTboneJackson · 6 pointsr/learnprogramming

> all of the courses on coding there will be using C [..] should I start learning C so that it'll be easier to follow classes for exams next year?

C is a completely different animal and learning more Python will do very little to help prepare you. If your intent is to get ahead of the game so you'll get the most out of your courses, then starting C now will help more than continuing with Python, IMO.

That said, C is much more difficult to learn, and you might need the help of an instructor more there. It really depends on the person. I learned C on my own from K&R. YMMV.

u/Teknull · 6 pointsr/C_Programming
u/puremessage · 6 pointsr/sysadmin

I know you didn't ask but I'm going to recommend this book: http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668

I picked up that book and I've been reading it. I've been a sysadmin for 10 years and the book is teaching me things. I'm impressed thus far. It's written the way that I want books to be written.

u/obeleh · 6 pointsr/compsci

Perhaps offtopic but... Some books you should read regardless of CompSci branch

u/dmazzoni · 6 pointsr/learnprogramming

One more to add: JavaScript: The Good Parts

(obligatory joke)

In all seriousness, it is a really good book.

​

u/Prozachian · 6 pointsr/webdev

I've read this book a couple times, technically it is about UI but it helps with how you should layout your page and the reasons why to lay it out that way.

Steve Krug's Don't Make me Think.
https://www.amazon.com/Dont-Make-Me-Think-Usability/dp/0321344758

​

You can also torrent it legally.

u/adriftatwork · 6 pointsr/engineering

Learn 'C' and 'Python'.

'C' is the lingua-franca of computers.
Start with K&R's 'The C Programming Language'.

Python as a high level language for getting things done. 'Dive into Python' is a good start.

u/PalmerDowneyJr · 6 pointsr/learnprogramming

Hmmm...

Like everyone said, it depends. Deep nesting can often be a code smell. This book will help answer your questions:

http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

But more importantly, please don't call yourself (or others!) a bad programmer! I'm sure you're just joking, but there's this weird vibe in the scene where people's worth is evaluated on their code. It kinda sucks. You're not your code.

A better question would be: does this pattern indicate poorly written code? The answer is GOTO: Hmmm...

u/quantifiableNonsense · 6 pointsr/java

The stuff you are learning in CS class is definitely important, but it's orthogonal to the things you will need to learn in the industry.

Read "Code Complete" to get a head start on this stuff. - https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

As far as some fun interviews with famous programmers, another great book is https://www.amazon.com/Practice-Programming-Addison-Wesley-Professional-Computing/dp/020161586X

u/JavaJosh94 · 6 pointsr/learnprogramming

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

u/c0demonk3y · 6 pointsr/java

The Pragmatic Programmer http://www.amazon.co.uk/Pragmatic-Programmer-Andrew-Hunt/dp/020161622X

Has a lot of similar stuff to Code Complete 2 but not quite as dense so makes a good primer.

u/win7dev · 6 pointsr/IAmA

>What would be the best way to prepare for these types of interviews? What sources/books did you use to study data structures and algorithms?

Get a friend and have them run you through practice interviews. Lots of them. Get used to writing code on a whiteboard, because it's different from writing code in an IDE.

For algorithm practice, I bought Introduction to Algorithms and Programming Pearls. I also did a lot of research online to find out the kind of interview questions to expect. (Ignore the brainteaser questions; Microsoft doesn't do them any more.)

For the most part, just hit the books, study hard, and write lots of code on a whiteboard. This article by Steve Yegge really nails it, I think.

u/JAPH · 6 pointsr/learnprogramming

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.

u/IRLeif · 6 pointsr/learnprogramming

Looks like most of your knowledge and experience so far is with imperative/object-oriented programming. You might want to have a look at functional programming, just to get some perspective. Scala, Erlang or Haskell could be some good choices here, or even Ruby (if you make use of blocks and don't use mutable data). Actually, Ruby is pretty cool and very versatile and practical, that could be a good language choice as well, and you would also be able to make use of your prior knowledge with OO programming.

One other thing that you could do with this time is to read some books! There are some wonderful "generic" titles that every programmer should read, in my opinion. Have a look at The Pragmatic Programmer, Clean Code and Code Complete, for starters. These might get you really inspired and pumped up for the undergrad college and computer science classes, as well as give you some good tips on new things to learn.

u/ForeignStudentUS · 6 pointsr/greece

freelancer.com, upwork.com και παρες όσες περισσότερες δουλείες μπορείς. Βιβλια που μπορεις να διαβασεις:

https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/ref=sr_1_2?ie=UTF8&qid=1482103739&sr=8-2&keywords=algorithms+and+data+structures

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_4?ie=UTF8&qid=1482103757&sr=8-4&keywords=software+engineering


Αν δεν ξέρεις κάτι google it. Η Ελλάδα έχει μεγάλες προοπτικές ανάπτυξης και πολύ καλό βιοτικό επίπεδο. Αν καταφέρεις και κάνεις κάτι μπορείς να βγάλεις καλά λεφτά κάνοντας εξαγωγές. Έχουμε υψηλό μορφωτικό επίπεδο σε συνδυασμό με το χαμηλό κόστος βιοτικού επιπέδου είναι θέμα χρόνου μέχρι να αρχίσουμε να εξάγουμε competitively priced τεχνολογία.

Αν εχεις ποιο συγκεκριμενη ερωτηση πες μου

u/com2kid · 6 pointsr/learnprogramming

Read Code by Petzold

You'll have a far greater understanding of how things work at a basic level than everyone else.

u/baultista · 6 pointsr/AskReddit

> Knowing one programming language, is of course, a must for any sort of programming. Knowing many programming languages is a bit less important, in a way. Many languages are very similar to one another and aside from the keywords, the syntax largely remains the same. If you've done Java before, then this means you could very well hold your own in C++, C#, and VB.NET for example.

I'd disagree strongly on this one. Writing VB.NET is very different from writing C++. I'd argue that programming language paradigm is more important. It's easy to switch between languages following the same paradigm because, beyond frameworks, libraries, and syntax, they are very much the same.

>Whenever possible, seek to make your functions about a screen's height. It's easier to follow the flow if you don't have to scroll up and down all the time.

Huh? That's a weird way to explain it. What's more important than number of lines is the Single Responsibility Principle. Every contextual item in your program (class, method, variable, etc) should only have one responsibility.

Otherwise I'd agree with this advice. For these little quips like these check out The Pragmatic Programmer, which is perhaps one of the best books that helped me move from a novice/junior developer to an intermediate/senior dev.

u/JavaTrainer · 6 pointsr/javahelp

There are a lot of different strategies.

  • UML/RUP (Rational Unified Process) Make lots of diagrams (UML) and lots of system requirements docs.
  • TDD - Test driven development. Make Unit Tests first and then make code that passes the unit tests.
  • CRC analysis - Napkin card type design that helps you figure out what classes you should have.
  • Service based design - SOA type stuff. Define some high-level service APIs that different parts of your application communicate. Great when multiple team members are implementing different layers of your application.

    Basically you asking a methodology question and not a programming question. If you are asking questions like this you should probably start reading books like Code Complete: A Practical Handbook of Software Construction, Second Edition
u/Constantine_V7 · 6 pointsr/cscareerquestions

This list isn't about "coding" per-se but is more focused on concepts, sw.en., practices, etc.

Thinking in Java is one of my favorites, the definitive introduction to object oriented programming and design.

Code Complete, Don't know anyone who hasn't heard of this so far

The Pragmatic Programmer: From Journeyman to Master

u/xashen · 6 pointsr/web_design

Don't Make Me Think is an excellent book on UX/UI design.

u/armchair_viking · 6 pointsr/smashbros

"Code" by Charles Petzold is a great book that does that. Starts with a simple flashlight switch, and builds on that example until you have a working processor.

Code: The Hidden Language of Computer Hardware and Software https://www.amazon.com/dp/0735611319/ref=cm_sw_r_cp_awd_FeDzwbRQ2ZDDP

u/Atanvarno94 · 6 pointsr/ItalyInformatica

Io direi di iniziare con il C.

Il manuale che consiglio(io) è, solamente, questo:

The C Programming Language: ANSI C Version

u/titsybox · 6 pointsr/learnprogramming

Perfectly normal. After 15 years of amateur programming I still make stupid mistakes and have dumb days and weeks when I get or seem to get nothing done. But like the saying goes it's only a problem if you don't learn from your mistakes. I can write a class get it working and come back to it in a week and can't for the life of me figure out why I'd done something a certain way. So my approach now is to break the program into modules and then classes which are independent as possible. Test those classes and finalise them as much as possible so I never need to modify them again and make notes on how they work. In fact I seem to make notes on everything I do. From theory to how classes in an API works to my own code. I've read somewhere programming is one of the most mentally intensive activities a human can do, so don't be surprised if you find it difficult at times, every programmer does I'm sure. Good luck 👍 oh yeah I forgot I'd strongly recommend reading code complete it helped me out more than any other programming book and it's lessons apply to any language. Think it even has a chapter on human factors

u/manbetrayedbyhismind · 6 pointsr/gamedev

Introduction to Algorithms. It's a great reference book for me now.

u/gineton2 · 6 pointsr/ComputerEngineering

For a gentle introduction, CODE: The Hidden Language of Computer Hardware and Software is a really pleasant read. It works its way up gradually, so maybe not the best fit for a physics student or someone who already understands the fundamentals. For someone new to the subject it's a great fit, however. Otherwise I see Patterson and Hennessy recommended.

u/philintheblanks · 6 pointsr/learnpython

That's an interesting pattern you have going on there. I don't know what kind of background you're coming from, but one of the nice things about Python is that, being dynamically typed, you can pass almost anything to a function at run-time.


What that means is, you can have a function like a spell that expects a character object, whether it's p1 or p2 is irrelevant. It holds the logic of how to access the object and alter the attributes. There's a LOT that goes into how you design that, but that's a thing that literal books have been written about.


So, as a brief example, you might do something like this:

def fire_spell(target):
target.spell_hits('fire', damage=2)
return target

class Character:
def init(self, name, health=10, mana=10, immunity=None):
self.name = name
self._health = health
self._mana = mana
self._spells = {
'fire': fire_spell
}

@property
def health(self):
return self._health

@property
def mana(self):
return self._mana

def cast_spell(name, target):
self._spellsname
return self

def spellhits(self, type, damage=1):
if self.immunity == type:
return None
else:
self.health -= damage
return None

So let's break that down a bit:


fire_spell: Exists outside of the characters. I would probably put all my spells in a separate module, that way I can import them, and add and remove them at run-time from the characters. That enables you to do things like have spells that aren't accessible prior to a level up, or some other mechanic. This isn't too different from having a separate class for the moves, since you're trying to namespace the moves, but I'll get to where that's a little odd here in a second.


self._health: This is just an attribute, but note the leading underscore. This is a pythonic convention that tells anyone who is using your code not to use this variable to access the thing that it points to. That is it would be best to leave it private. Python doesn't have private variables, so this is as good as it gets. We're all adults here.


@property: This is an example of a built-in decorator. If you don't know what decorators are, there are TONS of tutorials out there. Essentially, they modify how a function works. This one makes it so that instead of having to call the function, e.g. player1.health(), you simply access it as an attribute a la player1.health. Why on earth would you want to do this though? Well, any code in the function will run prior to returning the attribute! This allows you to modify what the calling code receives when it accesses the attribute. You want to have a conditional health buff based on the zone that the character is? Boom, way easier with this pattern. What to have the mana get dropped to 0 because of a status effect, easy peasy. And as soon as the effect clears, it can go right back to where it was! Basically, @property is really cool.


spell_hits: This is a method on the Character object. This you know. But why is it there? Well, designing a game is essentially designing an API. You may have heard of API around town, usually people are talking about web APIs, but the term is Application Program Interface. It applies equally to what this is. The Character class exposes an API to function inside of your program. They can expect that if they're going to receive a Character then they can act on it in a certain way. This is actually where you start to understand why certain programmers really aren't fans of dynamic typing. Python gives precisely 0 shits what you pass to this function. You can pass it a list of integers and it will not be annoyed. Well, until you try to call spell_hits. Then you get PropertyError: list object has no method 'spell_hits'. This won't happen until runtime. Then you're stuck chasing down which part of your gaht DANG CODE PASSED IN A DAMNED LIST!!!!! This probably won't happen to you with a small program, but I like to add context!


return self: Why would you do that? Well, we're back to the concept of API design! It's a pattern used for a "fluent interface". This pattern allows you to utilize method chaining, which is a really nifty thing. For example, let's assume that you want to run specific series of methods on a certain user input, then you could do p1.cast_spell(p2).use_item(p1).another_method(). This is a pattern that you see in a lot of libraries. It helps wrap your head around it if you write some code yourself that does it.


As far as your code is concerned, there's on thing that really sticks out:

Attributes.init(self)
Moves.init(self)

You don't need to explicitly call __init__. The __init__ function is what a lot of pythonistas refer to as a "dunder method", short for "double-underscore". I prefer to call them "data-model methods", since that tells you what they're actually a part of, instead of describing how they're written (which is totally useless information). A bit pedantic? Totally, but I wouldn't be a programmer if I didn't have a pedantic pet peeve (how's that alliteration!)


Data model methods are called when they need to be, and in the case of __init__ that is when you initialize an object. Example:

class Thing:
def init(self, name):
self.name = name

t = Thing('bobby brown')
print(t.name)

That will output 'bobby brown' because we assign the newly initialized Thing object to the variable t. Without capturing the object with a reference to a variable, they will be garbage collected. Basically, the Attributes and Moves objects that you're initializing will not be attached in any way to the player. You would need to do something like

self.attributes = Attributes(self)

Which would allow you to reference the new objects inside your player. Garbage collection in python isn't something that you'll need to be concerned about often, but I mention it because it's nice to know that python uses reference counting. Well, C Python does, and you're probably using that, so....


Overall, I think that what you need to get coded (pun intended) into your brain is the idea of frist class-ness, specifically as it relates to python. This concept is what makes decorators possible, and underlies the design patterns related to classes. I would also highly recommend the official tutorial as a place to find solid info on basics.


Past that, really it comes down to design choices. There's a million other ways than the one that I gave you to do this. Each one has a good reason to do it, and each one has trade-offs. This is where the rubber meets the road! Real programming boys! If you're interested in reading something that might help, I recommend Clean Code as a good read on designing good reusable software. The design book I linked above is kind of dense and uses Java, which could be confusing if you don't have experience with it. Clean Code is more generalized.


TL;DR: Functions accept objects, so pass the player object to the function and alter the health there. Then go read a LOT of stuff on OOP design patterns, cause they're hella hard.

u/maertsoi · 6 pointsr/learnprogramming

I'm kind of in shock no one has mentioned getting a good programming BOOK.

book!

Read it. Do the examples, answer the questions, experiment and break stuff.

u/tech-ninja · 6 pointsr/ProgrammerHumor

Depends what you want to learn. Some of my favorites are

  • Code by Charles Petzold if you want to know how your computer works under the hood.

  • Peopleware if you want to learn how to manage knowledge workers.

  • Clean Code by Uncle Bob if you want to learn about good practices and program structure. Impressive content, covers much more than I expected.

  • Don't Make Me Think if you want to learn about usability.

  • Algorithms by Robert Sedgewick if you want to learn about DS & algorithms.

  • The Art of UNIX Programming by Eric S. Raymond if you want to learn about the unix philosophy. Lots of hidden gems in there. Have you ever heard: write programs that do one thing and do it well; don't tune for speed until you've measured; imagine all this knowledge distilled to you in one book.

    This a good list to get you started :) most of my favorite books are not language specific.
u/Azzu · 6 pointsr/Cplusplus

> What's next?

I read plenty of websites to help out new or aspiring programmers, but this theme repeats like a thousand times and I just don't understand it. It's probably an issue with the system, but even then I still don't get why people are this way, it's as if they are not thinking...

Anyway. "What's next?" is immediately obvious to any rational person.

> I'm interested in making a game.

You do that. Tadaaa fucking done why did you even ask.

The problem is people are learning stuff for learning's sake. What the flying fuck? I just don't get it. You should learn stuff because you want to do something. You, OP, actually know what you want to do, making a game, so just... start? You will encounter plenty of problems along the way. You will research those problems and learn a huge amount.

If you notice you are lacking fundamental skills and just don't make any progress, read a fucking book. Have people forgotten that there are books on topics to learn those topics? I entirely taught myself C++ just by reading this, I have infos on how to get it if you want.

Also Go to StackOverflow and read the top 1000 questions (or how many you want).

There are so many resources on the internet... so many blogs to follow and read, so many tutorials to do.

I'm a little bit sorry that this is a rant, but I also included plenty of information so don't you fucking complain.

u/nthcxd · 6 pointsr/cscareerquestions

First of all, this is an excellent post. I've seen so many questions posted here but yours is the most concise and upfront. I know exactly what your background is and so I'm more confident that what I want to suggest would actually be relevant.

You have solid industry experience with academic foundation. And I think you already are aware of the pitfalls of expert beginner (http://www.daedtech.com/how-developers-stop-learning-rise-of-the-expert-beginner/). I think you are in a sweet spot where you can afford to invest resources without immediate gain - unlike early-career coders, you don't have to necessarily learn another language/framework right this second. You can afford to deepen your higher-level understanding of concerns and concepts that are timeless and not bound by the language/framework of the day.

I'd like to suggest you read other people's code/design. Here are some books to get you started.

u/boojit · 6 pointsr/explainlikeimfive

Related, this is a very good book about computing that happens to cover the history of the braille system in some detail. If you click on the "look inside" preview bit, and go to Chapter 3, most of the information relevant to your question is covered in these preview pages.

u/Gaff_Tape · 6 pointsr/ECE

Not sure about EE-related topics, but for CE you're almost guaranteed to use these textbooks:

u/hubilation · 6 pointsr/ProgrammerHumor

That's exactly how you should code. Uncle Bob taught us that.

Uncle Bob is love, Uncle Bob is life.

Read his book

u/developero · 6 pointsr/learnprogramming

Code is a great book that helped me understand programming on an abstract level

u/betterthanyoda56 · 6 pointsr/sysadmin

The Practice of System and Network Administration Second Edition. Filled with great advice. amazon

u/slowfly1st · 6 pointsr/javahelp

Since it's only a few weeks and you will use Java primarily, probably look primarily at the Java API's / components:

https://docs.oracle.com/javase/8/docs/index.html

(honestly can't find this overview page for newer versions java)

Collections-API is a good start (Map, List, Collection and so on and their implementations), I/O (read and write files), Concurrency/Multithreading (also understand the concepts), JDBC (connect to a database, read and write data). Date/Time-API. Probably networking.

Also learn all the language features. E.g. that there are three different kind of comments, know "all the keywords" (what's volatile and transient? I always mix them up ...), or what is try-with-resource?

If you're decent with java, you'll have,... let's say "one problem less"

​

Learn OOP/OOD: Read and understand those concepts is a good start: SOLID, Loose coupling, High cohesion, Information Hiding. Those concepts we do apply, so we can reuse parts of our code (so it's not duplicated), improve maintainability, interchangeability (like changing the front end technology to display the website without redoing the whole software), and so on. Not sure if that's too early for you, in the sense, that you are still learning the language and learning another "thing" is too much.

​

Databases are already mentioned (many applications use a relational database as 'backend'): Setup a database (e.g. postgreSQL or mysql, both are free), learn how to create tables (columns, datatypes, primary keys, [indices, constraints]), crud operations (create, read, update, delete data), how to restrict selection of data (where clause), how "to join tables", functions (max(), avg(), count()). Imo the basic concepts of 'relational databases' and how you get/change data is quite easy compared to learning a programming language.

​

Read Clean Code. (Probably too early for you, but I leave it here)

​

Probably have a look at HTML/CSS/JS. I really like w3schools, but mostly as a reference, because I don't know these by heart. Not sure if you have enough time, but try to learn some of the components of html and learn how to style them. It's actually quite easy compared to Java. If there's enough time, to learn some JavaScript may be helpful, too.

​

... and now combine everything :P - no, seriously: "Ship" a product - even if it's something small and irrelevant. To break down a problem into smaller problems and combine everything we know to solve those problems with the most elegant solution is what we do day in day out. And get your code reviews (e.g. here on reddit, the stackexchange-network has a good code review network, too). Because there's always a better and more elegant solution. If no one tells you, your code sucks (... or can be improved) and why, you keep writing bad code - or at least you won't improve as fast.

u/Bibdy · 6 pointsr/gamedev

Alright, in that case it sounds like you can benefit from 'the general advice':

  1. Make a 'vertical slice' of the game as early as possible. Networking, animation, scene loading, GUI, etc. This will ensure that every major library and tool you need gets in there early, and you workaround the conflicts between them before it becomes a burden to insert a new one. One of the big mistakes on one an early projects was to leave the entire GUI to the last minute, but because that 'conflicts' with general user input it was a huge chore to workaround certain issues after a lot of the user input code was in place.

  2. Trello is a handy tool for managing tasks, but I'm sure there are other perfectly good alternatives. Despite what you use, update your task list often and make sure you break things down into bite-size chunks that can be accomplished within between an hour or an entire day. That way you're always making progress and keeping your motivation up as that list gets shorter (although it will inevitably keep getting bigger as you break things down more, or remember things you forgot originally)

  3. If its taking forever and motivation is going down the tubes, cut features. Don't debate, don't haggle, just start cutting features to trim down the workload and get yourself back on track.

  4. Source control. Use it. Git with Bitbucket, or TortoiseSVN and VisualSVN Server Manager are my go-to solutions. It's both a log of your activity and your only saviour when things go wrong.

  5. Don't be afraid to tell people about your project, and never tell yourself someone is going to steal your idea, because you need as much feedback as you can get. And the earlier the better. My wife asked me why I'm so cavalier about telling people about my current project even though I'm only a couple of weeks into it, and its because everyone has their own project that they believe in, and when I mention my project to someone they're more likely to give advice on how to make mine better, or more like their own project (unconsciously giving away their own 'secret sauce' recipe), than they are to steal it and build out a competing product. People will only bother stealing an idea that's already been proven to work.

  6. Read books on game development and clean coding practices (if you haven't already). You'll be amazed what great lessons people are willing to impart for next to nothing, or even free (like I'm doing for you right now, incidentally). Two of my favourites are Game Coding Complete and Clean Code - A Handbook of Agile Software Craftsmanship.
u/chilldontkill · 6 pointsr/sysadmin

>I believe I understand the science behind procrastination, but I just can't seem to apply any methods to my life.

Do you have a ticketing system? No. Then, roll a ticketing system with email pickup. OTRS or RT.

If yes, immediately put in place a SOP(standard operating procedure) company wide, that all requests with the exception if critical ops are down, that all requests go through the ticketing system. Back that up with action. With no action, unless it comes through the ticketing system.

>I am the only IT guy at a 80+ user company (which is pretty lax most of the time). Because our ERP software is terrible (Which I didn't choose and constantly argue to get rid of)

You accepted the position and all its responsibilities. Stop trying to change what is and accept that yes you have a POS ERP solution. You're fighting the wrong way. You should be asking yourself how can I make this ERP work for me, instead of fighting to get rid of it.

>I spend most of my time at work generating SQL queries for basic user requests such as order statistics and the like. It turned me into a IT zombie where I procrastinate on all my IT projects unless it's directly in my face.

Can you not automate these procedures? Perhaps scripts users can execute on their own to for order statistics and the like?

> Before I started 4 years ago, I was always reading IT books and going to college and was enjoying learning and experimenting. Now, I almost feel afraid to read about new things or refresh my knowledge because I know I've been out of touch for so long.

You are spending too much trying to figure out the same things day in and day out. You need to start using a ticketing system religiously and start documenting everything. Everything.

> This gives me constant anxiety even while at home, knowing that there are a lot of things I need to work on but haven't in months, such as fully setting up vCenter/vMotion, Configuring the PS SAN array properly, etc. Whenever I try to work on a project, I feel it requires so many prerequisites, let it be knowledge/reading manuals or running out of network ports on a switch, that I'm in a constant juggle of accomplishing nothing.

As munky9001 said you need to let go of work when you leave work. With the policy and ticketing system in place. You can then only respond to operation crit emergencies. Then, when you get in the next day all your open tickets will be in your face to remind you what to do.

> I'm wondering if anyone out there has experienced a sense of losing flow and confidence as a sysadmin and what they did to get back in the game?

Every sysadmin has. You aren't growing enough and just dealing with the same bs. You need to prioritize, organize and document.

The way I attack my ticketing queue:

  1. In the morning I check for failures and the logs. Any emergencies I handle.
  2. I then do all the tickets that do not require me to leave my seat and do not take longer than 3 mins.
  3. I then process all the other tickets in the order they came in, of course prioritizing along the way.

    I also recommend reading:
    http://www.amazon.com/Management-System-Administrators-Thomas-Limoncelli/dp/0596007833

    http://www.amazon.com/Practice-System-Network-Administration-Second/dp/0321492668/ref=sr_1_1?s=books&ie=UTF8&qid=1344483754&sr=1-1&keywords=the+practice+of+system+and+network+administration

    A short version of both, at least read this.
    http://everythingsysadmin.com/the-test.html

u/MrInvisibility13 · 6 pointsr/wow

more employees = more code = more complex codebase = more bugs.

This is a useful book for understanding what's happening here: https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959

u/tango_oscar · 6 pointsr/gamedev

Best book to learn C++ in my opinion is Accelerated C++: Practical Programming by Example (350 pages). Right from the start, it teaches people to use STL containers and other C++ constructs, instead of teaching "C with classes" like many other books (including Thinking in C++). Unfortunately, it is outdated so you will have to learn about new features of the language. You can use A Tour of C++ for that(180 pages).

If you have the time and will to learn moder C++ from the start, then I would recommend C++ Primer. Similar in approach to Accelerated C++ but longer(970 pages).

u/jadae · 6 pointsr/compsci

I'd also recommend Code: The Hidden Language of Computer Hardware and Software by Charles Petzold. I recently finished reading this book after having it recommended by a post on Reddit a year or two ago. It starts off with a lot of basic information, covering Morse code and braille, and moves along in the development of code and hardware up until you actually create a functioning computer in the book. The later chapters were harder to get interested in, but the first 3/4 was very excellent and actually covered more than my computer architecture class in undergrad.

u/Gusfoo · 6 pointsr/startups

Perhaps.

But that aside, you should always throw away version 1. You now know far, far more about the reality of the situation than you did when you built your MVP.

Also. Go and read The Mythical Man Month.

u/NisusWettus · 6 pointsr/csharp

C# in Depth likely isn't what you need. That's more aimed at proficient coders that want to understand the nitty gritty/internals.

Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin) is very popular. Not specifically aimed at C# (a lot of the examples are Java) but it's guidelines about how to write clean code in general. The lessons carry over to all/most languages. That's probably more the sort of thing you want.

https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

Robert C. Martin aka 'Uncle Bob' also has a few other books but I've not really looked into them. e.g. this one is focused on C# and looks decent based on a quick skim of the index but I've not read it:

Agile Principles, Patterns, and Practices in C# (Robert C. Martin)

https://www.amazon.co.uk/Principles-Patterns-Practices-Robert-Martin/dp/0131857258

u/gingenhagen · 6 pointsr/programming

Try this book: Code, which is a bottom-up approach. Depending on how rigorous your college CS curriculum was, it'll be either a good review of your college classes or mind-blowing, but I think that the approach that the book takes is really great.

u/AMagill · 6 pointsr/engineering

Doesn't quite sound like what you're describing, but The Mythical Man Month is the book I've most often heard described as absolutely essential for understanding problems with managing software projects.

u/EughEugh · 6 pointsr/programming

There are several good books on designing good software:

Code Complete

Design Patterns

Refactoring

u/Murgolash · 6 pointsr/hacking

I may add the book.

Hacking: The Art of Exploitation

https://www.amazon.es/Hacking-2e-Exploitation-Jon-Erickson/dp/1593271441

u/Rikkety · 6 pointsr/AskComputerScience

Check out The Annotated Turing by Charles Petzold. It's Turing's paper on the Entscheidungsproblem which introduces Turing Machines, annotated with a lot of background information and some stuff about Turing's career. Very interesting stuff.

I can also recommend Code, by the same author which describes how a computer works from basic principles. It's doesn't have a lot of material on Turing, but it's certainly an interesting read for anyone interested in Comp Sci.

u/flares___ · 6 pointsr/programming
u/DigitalSuture · 6 pointsr/webdev

These gentlemen above my comment will be the exact answer you are looking for. Especially the save/make money comment. That is job security/advancement/streamlined processes all rolled into a concise statement. Pull information about what you need from UX/UI design, Steve Krug "Don't make me think" with small real world cheaply produced benefits, and also add in the fact of how many hours wasted to the company that the developers are spending trying to update something.

"Don't Make Me Think" by Steven Krug

How E-bay make 300 million dollars by moving a button. Design matters

u/bhrgunatha · 6 pointsr/AskComputerScience

A famous artefact of early computing is the boot-strapping process where the goal is a self-hosting compiler - which lets you write the compiler for a new language in the new langauge. However to get to that point a lot of earlier innovations were needed.

Take all of this with a pinch of salt - the order and the details may be wildly inaccurate, but the overall ideas viewed from afar give an idea of how we got to the point that we can choose our own language to write a compiler for another language..

To start with, raw binary values had to be set in order to define and run a program. Those raw binary values represent instructions that tell the hardwaer what to do and data that the program needed to operate. This is now usually referred to as machine code.

At first you would enter values into computer storage using switches.

Since that's so tedious and error prone, puched cards were developed along with the necessary hardware to read them so you could represent lots of values that could be read toagether. They had their own problems but it was a step forward from switches.

After some time symbolic instructions were defined as a shortcut for several machine code instructions - now usually called assembly language. For example put the value 8 and store it into a memory location 58 could be written as ST 8, [58]. This might take 3 machine code instructions, one represents the store instruction, one the value 8 and one the location 58. Since now assembly language could be written down it was easier to understand what the computer is being instructed to do. Naturally someone had the bright idea to make that automatic so that for example you could write down the instructions by hand, then create punched cards representing those instructions, convert them to machines code and then run the program. The conversion from the symbolic instructions to machines code was handled by a program called an assembler - people still write programs in assembly code and use assemblers today.

The next logical step is to make the symbolic instructions more useful and less aimed at the mundane, physical processes that tells the computer exactly how to operate and more friendly for people to represent ideas. This is really the birth of programming languages. Since programming languages allowed you to do more abstract things symbolically - like saving the current instructions location, branching off to another part of the same program to return later, the conversion to machine code became more complex.Those programs are called compilers.

Compilers allow you to write more useful programs - for example the first program that allowed you to connected a keyboard that lets you enter numbers and characters, one connected to a device to print numbers and characters, then later to display them on another device like a screen. From there you are quite free to write other programs. More languages and their compilers developed that were more suitable to represent more abstract ideas like variables, procedure and functions.

During the whole process both hardware - the physical elctronic machines and devices and software, the instructions to get the machines to do useful work - were both developed and that process still continues.

There's a wonderful book called Code by Charles Petzold that details all of these developments, but actually researched and accurate.



u/ajhandler · 6 pointsr/web_design

I agree with /u/Supernovadm I like tutorials where you can type the code rather than just read it. I think treehouse is great, especially when it comes to just starting.
If you pay for a month or two there you can rage through most of the html/css content they have and have a pretty good grasp.

If you're looking for a good book to start on these topics though I would suggest Html & Css: Design and Build Websites by Jon Duckett.

http://www.amazon.com/HTML-CSS-Design-Build-Websites/dp/1118008189

It's a super simple book. Very Visual and easy to read. Great start. Hope this helps!

u/ziptofaf · 6 pointsr/learnprogramming

Well, time to get a good C++ book then. Here's a decent one:

https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113

I am not even kidding here - programming is not something you learn in a day or two. It's a process that lasts hundreds of hours. Meaning you will need to practice and for that you need resources.


Well, to be fair - it really depends on your aptitude and a professor in question. If you were just told to have specific output but nobody has explained basic syntax ahead of the time then it's a shitty course. But if it was covered during the lecture and you just dozed off then it's on you. Well, one way or another it means you will need an extra time at home with a decent resource to work out your problems and learn programming.

Also - be a bit more specific. What kind of programs are you trying to write and what actually causes you problems? Literally not knowing how to write a line of C++? Or not being able to understand a problem and finding a solution to it?

u/anlutro · 6 pointsr/PHP

If the codebase is anywhere larger than a few tens of thousands of lines of code, a complete rewrite is absolutely out of the question. Any book that talks about working with legacy code will tell you this.

To get started, start with the small tasks. Fix code styling, make it readable without making changes. Break small pieces of functionality into classes with static methods (this makes it easier to navigate and reason about than regular functions).

If you can set up a testing suite somehow (it'll probably be easiest writing acceptance/functional/system tests than unit tests), that will give you confidence to make changes and check that everything still works.

There are good books on working with legacy code out there. Here are two off the top of my head:

u/qscedd · 6 pointsr/epicsystems

> Another thing I want to know is which programming languages/tools I should read up on. In my experience I've pretty much only used Java, Git and some basic HTML/CSS and Javascript. I know this is largely dependent on which team I end up on, but I might as well read up on something in the few weeks between graduation and my start date (early July).

AFAIK, we only use Java for the Android versions of our mobile products (MyChart for mobile; and Haiku). Most of our applications use HTML/CSS/JS, though, with use of these technologies increasing as we move away from VB6.

We do not use Git; instead, we use SVN. Maybe spend an hour learning how SVN differs from Git, if you'd like. But a lot of our SVN workflows have an extra layer of automation and hand-holding on top, so realistically, a deep knowledge of SVN isn't particularly useful or necessary for most developers.

I assume you've heard we use VB6 and M. Our internal training materials for these languages is superior to anything you'll find outside Epic. Don't bother hunting through an antique books store for tomes on either of them.

If you're bored and want to learn some job-relevant stuff, consider the following:

  • C# and ASP.NET. You'll very likely be trained in C# during your first month or two here, but it doesn't hurt to have a head start. You'll also be trained in the framework that we implement on top of ASP.NET. You never really learn about the ASP.NET layer directly, which is a bit unfortunate; I think it would be good for you to do some reading about that.
  • TypeScript. We'll have started switching over from JS to TypeScript by the time you get here. You may not understand how awesome this is. Trust me: it's mindblowingly awesome. TypeScript alleviates the pain of development for the web browser in a way that almost no other language/framework does (you have to start getting into esoterica like Emscripten to do any better than TypeScript, and then you start running into impedance mismatch issues).
  • Learn how to think from a testing-first point of view. I estimate that less than 1% of our code is covered by some kind of automated test (a unit test, an integration test, whatever). This is part of why we have such an enormous QA division (not that QA is entirely replaceable by automated tests, obviously). I don't recommend learning any particular framework (we have internal resources for the frameworks we use). Just learn how to write testable code; how to write good tests; how to develop with testability in mind; etc. Genuine test-driven development is not really feasible for most of the projects I've looked at, but even small steps in the direction of testability help.
  • Related to the previous point, learn how to deal with legacy code. This is not a skill you are likely to have fresh out of college, but it is a skill you will need in most software companies, and especially at old ones like Epic. The standard tome on this is "Working Effectively with Legacy Code". If you can find a cheap copy, I recommend buying it and skimming it. You probably won't really get it until you actually start working with our code, but better to be prepared than not.
  • Find a spiritual guru and have him teach you how to attain inner peace. This will help you not rip your eyeballs out every time you have to deal with VB6.

    > I guess my main concern here is that I just want to know if I should expect to be putting in 60 hour weeks.

    I have never worked a 60-hour week at Epic (unless you count time spent sitting in airports / on airplanes as part of the workweek, in which case I've worked one 60-hour week). My typical week is 35-45 hours (which, granted, is on the low end; 40-50 is more typical).
u/erreur · 6 pointsr/programming
u/strcrssd · 6 pointsr/java

Read and adhere to the guidelines presented in "Clean Code" by Robert Martin (Uncle Bob). The book could have been written as a response to this question.

Edit: krogger pointed out I misattributed the work. This has been corrected. Thanks Krogger.

u/jb2386 · 6 pointsr/PHP

Full rewrite in 1 go is the worst thing you can do. Doing it part by part will allow you to do it better.

Check this out of you haven't already: http://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052

u/ibsulon · 6 pointsr/webdev

Don't rewrite from Scratch: Joel Spolsky goes into detail as to why. Instead, rescue the existing code

I cannot recommend Working Effectively with Legacy Code enough in cases like yours. If done right, you can reach architecture without an end state.

The new way to do this is microservices. If you can properly consolidate your javascript in one place, you can start to break apart the monolith. It's absolutely possible to do in place, and you always have a product.

u/izut · 6 pointsr/programming

There's a pretty good book that touches the refactoring as learning tool subject: Working effectively with legacy code.

u/nolsen01 · 6 pointsr/compsci

Here is my advice, take it with a grain of salt:

  • There are lots and lots of flamewar worthy disagreements in computer science, programming and technology in general. Linux vs Windows vs Mac, Gentoo vs Arch vs Ubuntu, Ruby vs Python vs Java, Object Oriented Programming vs Functional Programming. Even within languages, certain frameworks have their loyalists and will tell you their favorite framework is the only way to go. Do not get mixed up in this. Follow your interests and enjoy what you're doing.

  • Be patient. Do not try to learn too much too quickly. Since you have another year or so before you start taking computer science classes, you are not in a hurry. You can take this time to learn some practical skills rather than just theory (which is what /r/compsci is all about). You'll find that your classes will teach you really interesting theoretical stuff like how to measure the efficiency of your programs or how to organize your code to make it more maintainable, all of which is very helpful, but it probably won't teach you how to use Maven or how to use some of the things that the industry wants you to know how to use. This is what I mean by practical skills. Its one thing to know what a Binary Search Tree is, its another to know how to use a specific framework. Spend some time on the practical stuff now. That means actually creating stuff like websites or video games (or whatever interests you.)

  • "The perfect is the enemy of the good." Don't try to make your programs perfect. Make them work and try to form healthy habits but do not be the type that settles for nothing less than perfection. If you do, you'll find that you hardly get anything done.

  • Pick one language to specialize in. You will learn more this way in the beginning. A lot of people have stunted their own progress by spending their first couple of years learning different programming languages. Don't do that. You'll learn other programming languages eventually, it really isn't that hard, but you're better off specializing in a specific language (for now) than being crappy at a lot of languages. (I made this mistake.)

    If you want to get good at programming, I would recommend the book "How to design programs" combined together with The Racket Programming Language. If you're really up for it, mix in the content from Structure and Interpretation of Computer Programs (which is a great book by the way). If you finished those, you'll have a very good foundation for learning how to program. I would learn a new language (don't specialize in racket) and continue from there.

    The downside to learning racket is that it is not a common language, however as I said earlier, you'll find that learning new languages it very easy so this shouldn't be too much of a problem, especially if you're more concerned with forming a good foundation first.

    After learning all of that, I would say look into something on data structures and algorithms. There are a lot of great books on the subject. Introduction to Algorithms is considered the classic. If you can get through the whole thing on your own, then you are better then I am.
u/theootz · 6 pointsr/cscareerquestions

TL;DR Improve yourself, invest in your future, don't worry about the mistakes...read the books listed at bottom, and practice!

Few months ago I royally fucked up an interview at Microsoft. A really simple question. But I had no experience doing coding on paper instead of a computer.

I spent a lot of time studying various books and paper coding to make sure it wouldn't happen again.

I then had an interview for another (in my mind at the time) dream job. I did fine for all the phone interviews and they flew me over to the west coast for an in person interview for the day. I did well for the first bit until they started pulling out dynamic programming and integer programming questions on me and expecting me. Once again something I didn't prepare for, and f'd up. Didn't get this job either. For the longest time I was really hard on myself at fucking up on both these interviews one after another. Especially this second one since a lot more was riding on it than just the job (another story).

But then I decided I didn't want to have this sort of experience again and expected better of myself. I made myself further improve and brush up on all those concepts as well. Did a few mock interviews with friends, spent some time working on interview type questions on both the computer and on paper. A month or two later I started interviewing again. By this point I was an interviewing machine - and I'm now able to do just about anything thrown at me. I've had my choice of employers and until just recently, was in the situation where I had so many offers I didn't know which one I wanted most. I'll be heading to silicon valley soon at one of the top tech companies in the world with a fantastic offer considering I just graduated.

The point is - learn from the mistakes and improve yourself. I realize you don't want to be that guy spending heaps of time coding outside of work or whatever... but this is an investment in yourself and your career. Do it once, and then just brush up on your skills from time to time. Get into the interviewing mindset and just rock them so you can have your choice of job - and then you can go about your thing once you have the job locked. The up front investment will be worth it!

Things that helped me:

  • www.hackerrank.com - practiced a lot of questions on here
  • www.careercup.com - another great site for questions
  • Cracking the Coding Interview More help on questions, but also some great insights into the interview process for the larger tech companies and many hints and tips on how to go about solving the more complex problems
  • Code Complete A great book for helping you to refresh or learn about software design
  • Eternally Confuzzled Great resource to learn how to think about common data structures and algorithms

    Having trouble with Algorithm design/analysis? These are some of the go-to books for that:

  • The Algorithm Design Manual Probably the defacto for learning about algorithm design and analysis
  • Introduction to Algorithms A great book with many different algorithms and data structures to learn about
  • Algorithm Design A great book if you want to dive deeper into more complex subjects like graph theory, dynamic programming, search algorithms, etc.. etc..
u/FattyBurgerBoy · 6 pointsr/webdev

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.

u/KidA001 · 6 pointsr/learnprogramming

Check out JavaScript, the Good Parts. Imo the best beginner JS book. No one should be able to save a .js file without reading it :)

You can learn angular without learning JS first, but it sure will help you go a lot further if you understand the fundamentals of JS.

http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742

u/MINOSHI__ · 6 pointsr/computerscience

are you talking about this book ?

u/RecycledAir · 6 pointsr/javascript

I've recently been working on my JS skills and heres a few resources I've found super useful:

Books:

Javascript Patterns

Javascript: The Good Parts

Javascript: The Definitive Guide (While an exhausive resource on the topic, this one is a bit verbose)

Web:

Mozilla's Javascript Guide (One of the best free online javascript guides/references.

How to Node (Tutorials on server-side Node.js)

Daily JS (Interesting JS related news)

Echo JS (Similar to above but updates less frequently)

Hacker News (This is more general tech news but there is a ton of useful web stuff, especially as node.js is currently a hot topic. Reddit actually spawned from HN)

Online Videos (free)

Douglas Crockford's Javascript Lectures (I would recommend these to anyone getting into javascript)

u/jhnsnc · 6 pointsr/webdev

First of all, don't worry too much about a single interview. A lot of interviewers don't really know what they're doing / why they are actually asking the questions they are asking. Usually, they're programmers--not experts at hiring people.

Having said that, you definitely want to be familiar with common "gotchas" and major issues in the languages/frameworks you will be using.

For JS, I recommend two books in particular: JavaScript: The Good Parts and JavaScript Patterns. I found these helpful because they cover all the major issues with the language and they are quite concise. These don't cover any frameworks like jQuery or Angular though--that's another matter altogether.

Also take a look here: https://github.com/h5bp/Front-end-Developer-Interview-Questions
There's a good chance the interviewers will straight up copy questions from this list and you researching the answers will be a great learning experience.

u/jacksonspumoni · 6 pointsr/salesforce

I studied for about 4-5 months. I work as an admin now with a little dev experience. Got about an 80-85% on the test. Here is what I did.

  1. Learned the basics of Java with this book: https://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208
  2. Watched all of David Lui's videos here: https://www.pluralsight.com/search?q=David%20Liu&categories=course&utm_source=sfdc99&utm_campaign=authordemo&clickid=SY0xd82tnxyJRtT08lQuCVrSUkgV-e3q3RXKQI0&irgwc=1&mpid=1192896&utm_source=impactradius&utm_medium=digital_affiliate&utm_campaign=1192896&aid=7010a000001xAKZAA2
  3. Did all of these trailheads: https://trailhead.salesforce.com/en/users/00550000006yDdKAAU/trailmixes/prepare-for-your-salesforce-platform-developer-i-credential
  4. Messed around a TON in my dev org making some visualforce pages and all that jazz.
  5. Read the entire Focus on Force study guide: https://focusonforce.com/salesforce-platform-developer-1-certification-practice-exams/
  6. Took the Focus on Force practice tests until I got a 100% on all: https://focusonforce.com/platform-developer-1-study-guide/
u/pootangina · 6 pointsr/minimalism

When you're working with other people, it's probably better to follow the code conventions set by the team or the company. That's for consistency and making your fellow programmers' lives easier.

Otherwise, I recommend you read Clean Code. You'll learn a lot about proper commenting, separation of logic into functions (Uncle Bob recommends short functions), and many more!

u/whereisspacebar · 6 pointsr/cscareerquestions
u/d00nutb00y · 6 pointsr/javascript
u/bob_twinkles · 6 pointsr/unixporn

All the code is up on github here, so feel free to poke around. If you have specific questions about the architecture or design I wouldn't mind answering those, but I don't have the time to walk you through everything line-by-line. If you need that kind of instruction I would refer you to the fantastic open.gl tutorials for OpenGL related stuff and a project oriented tutorial-style book like this one for Java for general programming concepts if you're just getting started. I'm not familiar with anything similar for C/C++ but perhaps someone can chime in with suggestions.

u/duskwuff · 6 pointsr/lolphp

Now I'm imagining a book titled "PHP: The Good Parts". (Kind of like "Javascript: The Good Parts".) Only, it's less of a book and more of a pamphlet.

u/KingEsoteric · 6 pointsr/AskMen

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.

u/joellarson · 6 pointsr/PHP

I've learned to enjoy writing similar to how Robert Martin outlines in his book, Clean Code

If I were to write this specific code by it, it would look something like this:

function retrieve_all_items_from_storage()
{
$result = DB::select("SELECT id, item, description, cost FROM items");

return $result;
}

function format_item(&$item) {
$item->item = "Hello " . $item->item;
}

function get_all_items()
{
$items = retrieve_all_items_from_storage();

if(empty($items)) {
return array();
}

foreach($items as $item) {
format_item($item);
}

return $items;
}


However, I would never write my example into my own projects because there would be a lot more complexity to it. For instance, I would have the retrieve_all_items_from_storage implement a data mapper, and have it return a Collection object, where I would do $itemCollection->isEmpty() instead of empty($items). It would also be organized into a multiple classes because of the nature of the functions. So while this is not something I would condone in your software, I firmly believe it is almost always better to have your method names define what a block of code does, rather than jamming it all into a function and commenting it out.

-- Edit --

I seemed to have missed the original question. If I had to pick, I would say the second block of code for similar reasons to what I outlined above.

u/Shadowhawk109 · 6 pointsr/learnprogramming

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).

u/smysnk · 6 pointsr/java

While you said books haven't helped, give this one a try: http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124

This website is pretty good also: http://sourcemaking.com/design_patterns



u/rowr · 6 pointsr/C_Programming
u/subl1m1nal · 6 pointsr/sysadmin
u/hvidgaard · 6 pointsr/learnprogramming

I can't really point you to anything online, but this book is one of the best on the subject. If you work your way trough that book, you will know more than most CS undergrads do about algorithms and data structures.

It's also a must have if you're implementing your own data structures every now and then.

u/MassiveFlatulence · 6 pointsr/java

Since you're experienced, the best way to learn Java is to start coding in it. Create a simple blog in Java using basic servlet + JSP hosted in Tomcat + JDBC connection to some free database (Postgresql / H2). You will find issues along the way which you can Google around. The best thing about Java is that most questions already answered in StackOverflow. After you've done with it, go and read Effective Java then refactor your project to follow the best practice mentioned in the book. After that you can try to learn more libraries / framework eg. create a new reporting system and communicate the blog with the reporting system through JMS. Adding dependency injection using Spring and many more.

u/Gardar · 6 pointsr/compsci
u/nobody102 · 6 pointsr/AskElectronics

There are plenty of tutorials on the net - http://computer.howstuffworks.com/pc.htm I would also recommend this book - https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

u/salamanderoil · 6 pointsr/AskComputerScience

It depends on what you already know.

​

Do you have any prior programming experience? If not, start there. My no. 1 recommendation here would be Allen B. Downey's free Think Python book. Others might come along and recommend something like SICP, which is a good book, but perhaps a bit hard for an absolute beginner. Downey also has a version of his book that uses Java, so if you know for a fact that this is the language your introductory programming class will be using, then that could be a better option (Python is a simpler language, which makes it easier for you to focus on the actual concepts rather than the language itself, but if you know that you'll be using Java, you might as well kill two birds with one stone).

​

If you do have prior programming experience, you have all sorts of options:

  • You could learn a functional language, like a Lisp (Clojure, Racket, Scheme, LFE, ...) or something in the (extended) ML family (Standard ML, OCaml, F#, Haskell, Elm, ...).
  • Or, you could go the other way and learn something low-level, like C. You could even learn about C and Lisp at the same time by building your own.
  • Or learn a logic programming language, like Prolog.
  • Or, if you really want to understand object-oriented programming (and how languages like Java managed to stuff it up), you could learn Smalltalk.
  • If you don't know what a unit test is or how to write one, you should learn.
  • Learn about data structures and algorithms. As a CS student, you'll be learning about them at some stage anyway, so there's no harm in starting early. Some people might recommended CLRS for this, but for someone just starting out, I'd recommend something a bit friendlier, such as this series of videos from Princeton (presented by Robert Sedgewick, author of one of the most popular books on the subject). If you'd prefer a book, this free one from Allen B. Downey (who also wrote the introductory programming text I recommended earleir) looks quite good.
  • Work your way through NAND2Tetris. It will take way longer than a month, but it will definitely set you apart from the rest of the class. Even if you don't do this now, you should definitely plan to do it at some point.
  • Learn about databases. Again, you'll have to study them eventually, so why not start early? You could start by trying to build something that uses a database, like a simple todo utility.

    ​

    Regardless of whether or not you have programmed before, I would also recommend doing the following:

  • Learn some basic Unix skills. It doesn't have to be too much – just enough to be able to sit down at the command line and have a vague idea of what you're doing is fine for now. You'll learn more as you use it more. That said, if you really want to dive in and learn how everything works, then something like How Linux Works could be a good read.
  • Learn some discrete mathematics. As a CS student, you'll be required to learn it at some stage – it's the mathematical backbone of CS, much like calculus is to physics – so you might as well start early. This free, book-length set of notes from MIT is very well-regarded (but don't expect to get through it all in a month!). There is also a set of video lectures if you prefer. If you're keen on learning functional programming, another option could be to integrate that with your discrete maths studies by reading Thomas VanDrunen's Discrete Mathematics and Functional Programming (if the physical book is a bit expensive for you, there's also a cheaper ebook version available).
  • For bonus points: learn to use either Vim or Emacs. There probably isn't a massive practical advantage to using these this early in your career (although they could certainly come in handy later), but if other students see you writing code in one of them, you'll look like an absolute badass. Your teachers will probably be quietly impressed, too.

    ​

    if you have any questions about my above suggestions, let me know, and I'll see if I can point you in the right direction.

    ​

    Good luck!
u/aogan · 6 pointsr/programming

I can't believe that no one mentioned Code Complete: http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?ie=UTF8&s=books&qid=1267359531&sr=8-1

It totally changed my perspective on writing applications, no matter what the language or scenario. HIGHLY recommended - every programmer should read it.

u/SanityInAnarchy · 6 pointsr/learnprogramming

I don't think there is anything you need to cover before the class, if it's a good class. However, I would suggest the following -- not before class, but probably before, during, and after class:

  • If the class goes reasonably well, pick up this book. It's a collection of best practices for Java. You will learn bad habits in class, and this will help. (It's not necessarily the class's fault, it's that Java warps your brain in all the wrong ways.)
  • For Java, learn Eclipse, and learn it well. You may find you prefer other IDEs, but Eclipse is among the most popular, it's open source, and Google builds things on it, like the Android and Dart SDKs.
  • Learn source control. It doesn't matter which you pick up first -- in my opinion, SVN was easier to learn, but Git is the best all around, once you get past the learning curve. And once you learn a distributed VCS like Git, you can use it on class assignments -- which I recommend doing, whether it's required or not. (And always make sure you tell your VCS what to ignore. Like, ignore .class files.)
  • That said, learn to do things without the IDE, so you understand what the IDE is doing for you.
  • Extra credit: Learn other JVM languages, like JRuby, Clojure, or Scala. In particular, learn at least one with a good REPL. This may be confusing, because you're using more than one language at once. But it also helps when you want to explore how a Java library actually works, in real time. I haven't found a good Java interactive shell, which is why I use JRuby's IRB for that.
  • Google any term I used above that you don't understand.
  • My experience with a community college was much worse than my experience with a university. If a university isn't practical, I understand... If it fails you -- that is, if you find yourself asking the professor questions that they can't answer, or if their answers don't make sense, don't be afraid to come back here or to StackOverflow.
  • If the in-class projects aren't big enough, start one out of class! Practice is what makes you a better programmer and better with the language, and the best way to practice is to give yourself a project that you're actually interested in. Work your way up from Hello World, but if you find yourself not wanting to practice, you probably need an exciting project.
  • Don't stop with Java. Learn other languages, learn other ideas. That said, when you find something you're really into, specialize and master it -- but you'll still always need to be stepping outside of that. Keep in mind that your skills in all likelihood will become obsolete. You don't need to chase every programming fad, but you do need to stay on top of the pulse of the programming community.
u/Wentzel142 · 6 pointsr/cscareerquestions

I'm just about to graduate with my undergrad in CS with a specialization in HCI, and have had multiple UX internships. Read these two books, they'll provide a really good baseline of knowledge about user-centric design.

The Design of Everyday Things - Don Norman

Don't Make Me Think - Steve Krug

While the second one typically focuses more on web, they're both amazing books that should be in the library of any UX/HCI specialist.

The best way to start building a portfolio is to, well, just do. Find anything (not just a program/app, even) that you don't like the design of, and start from there. Try and redesign it to make things easier to figure out. Show it to others to gauge reactions and get feedback. Iterate and improve.

There are a bajillion different programs for UI prototyping, but the first tool I'd suggest is good ol' pencil and paper. Get yourself a sketchbook and keep it in your backpack (or with you in some other capacity) at all times. When you have a design idea, drop everything, make a quick sketch, and go back to what you were doing. Ideas are fleeting and temporary, so it's best to get it on paper before you forget. Once you've got time, try and improve on those designs and think of what would work and what wouldn't. After you're happy (and have shown it to others for feedback), take it into some prototyping app like Balsamiq, Indigo Studio, or Sketch. Render it in high quality and start seeing how users would react to it in its natural setting (put it on a phone, or on a computer, etc. for testing). It's all about getting user feedback because one person on one computer may not have all the right ideas.

tl;dr: Read books. Redesign crappy things. GET A SKETCHBOOK. Feedback, feedback, feedback.

u/mmmguitar · 6 pointsr/java

Like most time in my job, I dont have alot of time to look at code, so something I find important is how clean / understandable the code is and at a glance its where I'm struggling with your code.

In particular, process request seems to be 200 odd lines long, doing many things and branch / nests alot and to understand you have to delve in to the guts of it and also read comments (which on shared code will go out of date). I think the complexity would really show if you try to unit test the code.

Clean Code is an awesome book on the subject. At times may go over the top a little but the message is great.

So to break that method down and make it cleaner / more understandable you can do 2 things. Firstly, small private methods that self document:

For example in the middle of the method you do this with a comment:


//----- DATA SEPARATOR -----//
String delimiter = "\t";
if ((REQUEST.get("FILE_DELIMITER") != null) && (REQUEST.get("FILE_DELIMITER").length() > 0)) {
String sep = REQUEST.get("FILE_DELIMITER").trim();
if ("COMMA".equalsIgnoreCase(sep)){
delimiter = ",";
} else if ("PIPE".equalsIgnoreCase(sep)){
delimiter = "|";
} else /if ("TAB".equalsIgnoreCase(sep))/ {
delimiter = "\t";
}
}

could be extracted to this:


String delimeter = getDeliminator(request)

....
}

private String getDeliminator(Request request) {
if ((request.get("FILE_DELIMITER") != null)) {
String sep = REQUEST.get("FILE_DELIMITER").trim();
if ("COMMA".equalsIgnoreCase(sep))
return ",";
else if ("PIPE".equalsIgnoreCase(sep))
return "|";
}
return "/t"
}

The advantage with that extraction is now processRequest has got smaller and there is now 1 line saying get delimeter that I can understand straight away because the name of the method is saying what its doing. Because of that you don't need that commend and the code becomes self documenting.

Its also simpler because there is no longer variable being defined with a default value that may or may not get overriden.

The delimeter calculation logic is now wrapped up in a nice little method that does 1 thing. Ultimately processRequest doesnt care how the delimiter is calculated, just that it gets one.

Everything has got a little cleaner and simpler.

So yeah there's many places that that sort of extraction / self documentation will help. Generally speaking a method should do 1 thing, if its over 4 lines long then it may doing too much (ok that quite extreme, but long methods are a sign of methods may be doing too much)

The second thing that may help is breaking that class up a bit. Its doing a lot, processing request, generating a file, doing all sorts of things with processing, writing the file out.

If you break things up a little you can reduce the complexity of whats going on, i.e. process request process the request and leave it up to something else to do file generation etc.

Its handy because it greatly simplifies testing, you can then starting testing the individual components. More along the single responsibility type idea.

A couple of other quick things I noticed, only use CAPS variable names for static instances. You have dual variables request and REQUEST doing differrent things,, i dunnore, request and requestTable?

Theres also a couple playes where you are catching an exception and doing nothing, it supresses the exception, generally thats bad, at least do a stack trace or log the exception happened. Its hard tracking down bugs / odd behaviour when exceptions are suppressed.

u/Wayne_Enterprises_ · 6 pointsr/userexperience

This should get you started :)

Books:

u/Razzal · 6 pointsr/javahelp

For a good beginner book that I think explains things well, look at Headfirst Java.

http://www.amazon.com/Head-First-Java-2nd-Edition/dp/0596009208

u/yoodenvranx · 6 pointsr/de

Falls du wissen willst wie eine CPU funktioniert und was Assembler ist und vor allem wo das alles her kommt und warum es funktioniert, dann kann ichdir Charles Petzold - Code: The Hidden Language empfehlen. Er fängt mit einfachen Morsesignalen an, leitet dann Logikgatter her und am Ende des Buches hast eine eine funktionerende CPU.

u/s3ddd · 6 pointsr/netsec

wartex8 mentioned it, but I can't speak about Hacking: The Art of Exploitation highly enough...

u/yawpitch · 6 pointsr/learnpython

Just gonna say it; if you're not using function and/or class definitions in every file then you haven't learned Python or programming. Not yet.

Most of professional programming is maintaining code, usually in concert with others; you must be using factorization primitives -- in Python that's functions, classes, and modules -- to write code that is even testable, which is the start of being maintable.

I would suggest starting with a book like Clean Code.

u/WaxenDeMario · 6 pointsr/cscareerquestions

Yes! Also, quite honestly I don't know that many CS majors who took linear algebra at my school for whatever reason.

Where do you get started?

  • If you're the type of person who likes an organized class to learn concepts, consider checking out coursera or other similar websites which offer free online learning courses! Check out their CS offerings and start from the intro.

  • I must be known for spamming this SR with this, but check out CLRS, it pretty much contains most of the "CS math" you need to know for algorithms. As well as pretty much all you need to know about Algorithms and Data Structures for any basic job.

  • REALLY make sure you understand your Algorithms and Data Structures, nearly every interview for a basic position centers around these topics. As well as some others, depending on the company: Bit manipulation, multi-threading, TCP/IP, etc.

  • You want to learn some mainstream language as a lot of other people mentioned: C++, Java, C#, Python are a few that come to mind (though there are more like Ruby!). Side Note: Some people have differing opinions on whether C++ is good to learn as a first language. I don't know C# (but from its apparent similarity to Java) I would say C++ is probably the most difficult language to learn of the four I listed, but I feel that it also provides the most flexibility, because once you understand C++ it's easier to trainsition from C++ to Java, than say Java to C++ (similar for the other languages).

  • Practice! Start working on some Project Euler problems, or other practice problems. Bonus: Someone in another thread mentioned that they made a blog post for each problem they solved and explained every one of their design decisions. This seemed like a bit over the top, but it really is a good practice for an interview and a job! You can even put a link to this on your resume to share.

  • Find an Open Source to contribute to, come up with your own projects and post them on your github! This can show off your skills to a potential employer!

    Bonus for programming:

  • When coding alone it's easy to get lost and start "hashing" together code. When you get to big projects, you'll find that this causes a lot of problems (and when working with other people it can cause even more). Some things to keep in mind when coding:

  • Make sure your code is maintainable.

  • Make sure your code is scalable.

  • Test, test, test!

    Maintainable kinda means that your code is easy to test, easy to comprehend (by others) and easy to modify. Read up on different design patterns to learn more about this.

    Scalable is something you'll learn more about later, but basically it's kind of thinking about whether your code will be "good" enough to handle a lot of users (how fast is it how much memory will it take up)

    Testing is very important when coding. You want to try to write small pieces of code then test it (i.e.: make sure it works).

    All three of these things show up a lot in interviews, and if you can relate why you made your code the way you did to one of these three points (or something else) you should be pretty well off :D

    How do I land an interview?

  • In your resume make sure to list any CS projects you want to mention, a link to your website (if you have one) or to other work. As well as Operating Systems you're familiar with (Linux is a big plus, but not absolutely necessary), IDE's you're familiar with (things like Eclipse, Visual Studios), and Languages you know. If you can, make sure to relate those three bullets to your project and work somehow to reiterate your experience with each language.

  • A lot of recruiting is done on-campus, but there are other options, like applying online or even better...

  • Network your way in. This gets your resume through the massive HR screen

  • Edit, edit, edit (ask friends who are in the industry).

    How do I study for an Interview?

    Typcially, an interview will have you and the interviewer. The interviewer will first ask questions about you, what you're majoring in. And then maybe ask questions about your previous projects, and then he'll throw you a programming problem. Sometimes these can just be questions like "Which is faster: quicksort or mergsort?" or something like that, but other times they'll have you code something. If the interview is online, this will either mean you'll need to tell them the code you're writing or you'll code online on some collabarative envirionment (i.e.: you type the code online). If it's in-person they may have you write on a whiteboard. There are other formats of interviews as well, so make sure to research. Typically, for most larger companies, they won't care what language you code in (hopefully though it's mainstream!), but if you don't code in a language which they use, they may test you later for proficiency in one of their languages.

  • As I mentioned before, Algorithms and Data Structures are usually go-to's for interviews, but other topics may come up so check out the req's for each job specifically.

  • It may have been a while at this point since you studied your material, to brush up on interview questions, Cracking the Code Interview is a great book to brush up on your topics for an interview, it also has some resume advice, etc. if you choose to follow it.

  • Be sure to practice talking out loud while you're coding, as this can help you during interviews. If you're stuck but your thought process is good an interviewer can help push you in the right direction.

  • If you struggle with interviews, try having a friend who you know has experience and having him ask questions, better yet if you know a friend at the company, ask him to mock interview you.

  • If you have time ALWAYS make sure you run test cases through your code mentally, and mention the test you're running and what it's supposed to catch (expected behavior) to your interviewer! If you have time and choose to ignore these, it can give the interviewer a wrong impression :\ (it also makes you look really good if you come up with all the boundary cases)

    Sorry, not sure if this helps or not!
    Good luck!
u/NerdyTerdy · 6 pointsr/learnprogramming
u/novembersierra · 6 pointsr/cscareerquestions

Code: The Hidden Language of Computer Hardware and Software

This book starts with flashlights and Morse code and Braille, goes to telegraphs and electricity, works it way up to Boolean logic gate circuits (still using the components from telegraphs!) and then goes all the way to programming languages and computer graphics.

u/yanalex981 · 6 pointsr/learnprogramming

http://www.amazon.ca/Primer-5th-Edition-Stanley-Lippman/dp/0321714113

There are two books with very similar names (C++ Primer, and C++ Primer Plus), and usually, this is the one that's being referred

u/Zippy54 · 6 pointsr/Android

This is from my own personal experiences. Please, learn Java first, I cannot stress this enough. Knowing Java helps so much with design, I struggled with basic Java knowledge and hated programming for Android; I recommend Effective Java 8th Edition .

Be warned though, it's not very friendly to novice programmers, so I'd make sure you have experience in any 'C' based language beforehand - C++ would be a great help.

I'm really not trying to be a dick here, but you really do need to learn Java to a sufficient level. Do you know: Java Inheritance, Static Functions, Abstract Classes, 'For Each' operator? Mutaor Methods? Trust me, this will all come up in Android and more over, Android uses most of Java's library.

Please, I don't want to sound like a huge Dick, but this is crucial. Let me put this is into a metaphor. Learning the Android API without Java is pretty much suicide (I can't think of any good metaphor(s)).

I hope this helps, Oh and Inbox me on Reddit - I might have a few books for you.

u/Skridg · 6 pointsr/hacking
u/intertroll · 5 pointsr/compsci

If you don’t want to real an actual textbook, this one will do the job (without skimping on details) and is more laypeople friendly:
https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

Just as an aside, I had a non techy friend who had a similar sense of mystification as OP’s but really wanted to understand them better, so I pointed him at this book. The next time I saw him we had a great conversation about logic gates and data representation. So it works! It was actually almost a cathartic experience, taking a person who doesn’t get to someone who does, since as a developer you often have to deal with users who don’t know and don’t care.

u/atommclain · 5 pointsr/apple

For the 'computers in general' side of things: Code: The Hidden Language of Computer Hardware and Software

u/TotalPerspective · 5 pointsr/bioinformatics

Here are some books that I feel have made me better professionally. They tend toward the comp sci side, some are more useful than others.

  • Bioinformatics: An Active Learning Approach: Excellent exercises and references. I think most chapters evolved out of blog posts if you don't want to buy the book.
  • Higher Order Perl: I like perl to start with, so your mileage may vary. But learning how to implement an iterator in a language that doesn't have that concept was enlightening. There is a similar book for Python but I don't remember what it's called. Also, you are likely to run into some Perl at some point.
  • SICP: Power through it, it's worth it. I did not do all the exercises, but do at least some of the first ones to get the ideas behind Scheme. Free PDFs exist, also free youtube vids.
  • The C Programming Language: Everyone should know at least a little C. Plus so much has evolved from it that it helps to understand your foundations. Free PDFs exist
  • The Rust Programming Language: Read this after the C book and after SICP. It explains a lot of complex topics very well, even if you don't use Rust. And by the end, you will want to use Rust! :) It's free!

    Lastly, find some open source projects and read their papers, then read their code (and then the paper again, then the code...etc)! Then find their blogs and read those too. Then find them on Twitter and follow them. As others have said, the field is evolving very quickly, so half the battle is information sourcing.
u/bjarneh · 5 pointsr/java

this book is often mentioned among the best programming books ever written; together with Larry Wall's (Camel) Perl book, and Dennis Richie's C book.

Effective Java

http://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683/ref=sr_1_1?ie=UTF8&qid=1314549239&sr=8-1

u/Drcool54 · 5 pointsr/UIUC

Okay I came in to school like you with very little programming experience. Probably even less than you since I only messed around on my TI. I am going to assume you're only taking ECE110 first semester. If not I recommend getting in as soon as you can. They may give you some crap about it depends on last names, but it doesn't really matter. After a certain point its open to everyone.

Either way, programming in ECE doesn't really start until you take ECE190 which is all C programming and a very simplified assembly language for educational purposes. Like I said I went into the class with practically zero programming experience and still did very well in the class, so don't let anyone scare you on that. If you put the time aside to read the book (really helpful in 190) and doing your MPs/ask the TAs questions you will do fine.

I wouldn't fret too much over the summer with learning stuff, but I would definitely recommend C over Python. Python is pretty easy to pick up, but its also very high level. If you need an introductory language to get familiar you can try python for a bit, but I'd go with C after that. It is worth noting that the other two required programming class you have to take (CS 225 and ECE 391) are C++ and C/x86 respectively. So learning C should definitely be your focus.

I recommend the book written by the creators of the language. The book the school requires is pretty good too actually and would give you a better idea of what to expect. They're kind of pricey, so its your call how you want to get them. As a heads up, codecademy does have Python, but not C as far as I recall. I've never used lynda do I can't comment on them C Book ECE 190 Book

I honestly wouldn't fret too much about it all. Enjoy your summer, depending on how busy your schedule is next semester you can probably set aside some time now and then to study some languages. If you have any more questions I'd be happy to answer.

u/Zuslash · 5 pointsr/webdev

I found Lynda.com to be extremely dry and slow. To me it was the equivalent of those old school mandated educational movies you would watch in classrooms back in the 90s on your faux-wood tv. Take this opinion with a grain of salt though as it has been almost two years since I have looked at anything on Lynda, I hear it may be better today.

If you are looking for web development in particular I would suggest the following:

  • Codeademy - Free and very good at introducing basic web development skills.
  • Team Treehouse - Paid subscription but well worth it in my opinion as they will walk you through everything from the most basic HTML to building advanced JavaScript applications.
  • CodeSchool - CodeSchool tends to be more advanced and I would wait until you have a strong grasp on your HTML, CSS and JavaScript before investing in their coursework.

    In addition, StackOverflow; A general programming Q&A website, has an answer to just about any programming issue you may be running into. If the answer is not already there, then chances are you will have one within 24hours.

    I began my pursuit into web development about 2 years ago. In that time I have gone through the resources listed above as well as the following books which have helped immensely:

  • HTML and CSS: Design and Build Websites - Ducketts whole series is extremely friendly to the new web developer and will help you build a solid foundation quite quickly.
  • JavaScript and JQuery: Interactive Front-End Web Development - Another Duckett book which was just released focusing primarily on JavaScript.
  • JavaScript: The Definitive Guide - A massive JavaScript reference. It has answers to just about everything.

    Some personal career history if you're interested:

    In the last two years I have gone from making 18k a year as a Technical Support Representative to 80k a year as a Front-End Engineer building JavaScript applications at a large FDIC Bank. It was only in the last two years that I really dug into Web Development (and programming for that matter) and I really can't see myself ever doing anything else for a living. The job requires an immense amount of learning (which I love) and will keep your mind sharp. I really do get a kick out of problem solving all day. Programming will require a major adjustment to the way you think. I can say that the way I work through problems now is completely different to the way I did before. I feel as if critical thinking has eluded me until the last two years and it has been a major life changing event. By far the biggest contributing factor to my growth has been the team I work with. You have to do your best to find a team that is willing to work with you as a junior so you can siphon that knowledge. Even if that means taking a low paying job, however; know your worth so that you can ask for the right amount of money once you have gained the necessary skills. As a personal rule of thumb, I will not stay at a company where I am the most knowledgable member of the team. This inhibits growth as a developer and will prevent me from realizing my true potential.

    Feel free to hit me up if you have any questions.


u/videoj · 5 pointsr/learnprogramming

Data structures and Algorithms Write code to impleement every (or even most) and you'll be well preparped.

Design and Testing here.

Programming Languages here.

Also look for an open source project that needs help and provides you with experience in one or more of these areas (or start your own). Code is always a good way of showing you know something.

u/Pardon_my_dyxlesia · 5 pointsr/hacking

I was personally recommended by my mentor Hacking: The Art of Exploitation, and The Web Application Hacker's Handbook: Finding and Exploiting Security Flaws
Also some companions sent me some readings on index articles. I'm not so sure of the titles, but just browse around.

http://slav0nic.org.ua/static/books/

http://hackbbs.org/article/book/

u/Cole119 · 5 pointsr/learnprogramming

K&R is the go-to C book, IMO.

u/eric_weinstein · 5 pointsr/learnprogramming

Seconding The Pragmatic Programmer and Cracking the Coding Interview. I'd also recommend:

  • Code Complete: verbose and somewhat self-congratulatory, but extremely good.
  • The Mythical Man-Month: a little dated and weirdly religious at times, but has great insights into how software problems are actually people problems and how large projects are (mis)managed.
  • Design Patterns: a.k.a. the Gang of Four book. This one's a classic.
  • Pro Git: you mentioned version control systems. IMHO, you should learn Git if you don't know it, and this book is a great resource.

    If you let us know which languages you primarily write, I can probably recommend some good language-specific titles, too.
u/realfizzbuzzed · 5 pointsr/learnprogramming

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.

u/xorxorxorswap · 5 pointsr/rutgers

Read "The C Programming Language" ( https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628 , it's also on libgen)

​

Make sure you're cool with data structures (most of them are important, but hash tables are very key because they form the basis of caches, something you'll have to learn)

​

Look up some basic digital logic (up to flip-flops and d-latches, and cover some FSM too if you have time)

​

I don't really know of any great resources to self-study assembly, so you'll have to just make the most of the lectures on that.

​

Prof Nagarakatte is super fair imo. Multiple project extensions, a multitude of extra credit opportunities (I believe it totaled to something around 15% of the total course grade with max extra credit when I took it), and no curve- you just need an 85% (after extra credit is applied) to get an A, which is nice. The best thing about him, though, and something I've never seen anywhere else, is that the TAs know what they're doing. He tries to get his own grad students TA positions, and so he's got a great working relationship with them. Go to recitation, because the TAs know what's up and will often write out significant portions of the projects for you. In my opinion, the course wasn't particularly easy, but an A is definitely achievable as long as you put in the effort. His lectures are pretty fast, but the slides are online and fairly self-explanatory, so try to go over them after each lecture if you can.

u/khazarboy123 · 5 pointsr/CrusaderKings

Ok I actually understand this, because I took Computer Systems and had to read http://www.amazon.com/Hacking-The-Art-Exploitation-Edition/dp/1593271441. This is awesome.

u/umib0zu · 5 pointsr/AskComputerScience

You should probably start with this book called Code and work your way up from there. It's actually pretty hard to find a single book that describes the history and the concepts, and even if you did find one, most of the topics would be hard to grasp on a first read. Code is usually a great starter book and might give you a few pieces of what your looking for. After you finish it, maybe check out a software book and dive into some of the concepts.

u/1337_Mrs_Roberts · 5 pointsr/suggestmeabook

Hofstadter's Gödel, Escher, Bach

If you like things a bit more prose-y, try Pirsig's Zen and the Art of Motorcycle Maintenance


u/CameronNemo · 5 pointsr/linux

Haha, sorry it is a commonly referenced book I did not even think about it.

Brian Kernighan and Dennis Ritchie (early developers / creators of UNIX) wrote a book called The C Programming Language. Make sure you get the second edition though.

u/hendrikdelarey · 5 pointsr/computerscience

https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X This is a book I usually advise junior developers to read. Another one is Clean Code by uncle Bob.

u/thatsnotgravity · 5 pointsr/learnprogramming

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.

u/robertcrowther · 5 pointsr/programming
  1. He's not the author
  2. The book was published in 1994
  3. Java was first released in 1995
u/CuttingEdgeRetro · 5 pointsr/learnprogramming

I learned it from this book around 25 years ago:

https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628


But you can probably save the money and just use any tutorial on the internet. I'd recommend just starting out with C++ though. When object oriented programming went mainstream, I had a lot of trouble switching over to the new mindset. You're better off learning OO from the beginning.

u/liftdeadtrees · 5 pointsr/learnprogramming

I like the book Head First Java if you have some programming experience. If you need something more basic (actually it's probably very similar to your class), Stanford has their Intro to CS class online here. It's in Java, and the teacher is pretty entertaining.

u/Lavender_poop · 5 pointsr/marketing

I have a few, not all specifically about marketing but related to business, growth, customer experience, etc.

u/jdmas · 5 pointsr/cscareerquestions
u/jesyspa · 5 pointsr/learnprogramming

If you're very far already (using the language for over a year, for instance) you could try to fix the gaps by watching Going Native talks and reading A Tour of C++. If you're just starting out, I suggest either getting C++ Primer or The C++ Programming Language and working through that.

u/UncleMeat · 5 pointsr/compsci

I cannot recommend the book Code by Charles Petzold highly enough. This is the book that solidified my love of computer science and hits most of the major topics in CS in an easy to understand and thoroughly entertaining way. By the end of the book you have walked through the fundamentals of how to build and program a rudimentary computer and had fun why doing it!

http://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

u/masterdirk · 5 pointsr/teslamotors
u/DrAmbulanceDriver · 5 pointsr/learnprogramming

I'm assuming you just want to learn the basic information about how computers work and the principles behind programming them, right?

In that case, I'd recommend Code by Charles Petzold

Are you looking to actually learn how to program and write code in a specific language? If so, then I'd recommend Automate the Boring Stuff with Python by Al Sweigart. It covers the basic principles of writing functions and how computer logic works, and you'll actually be able to apply it to some practical uses. And since its Python, it'll run on a lot of different platforms. If you like it, you may want to get into working with the Raspberry Pi. Javascript is another good language to start with, but as a book, I really like this one.

If you already know a bit about programming, and just want a general reference book, then Computer Science Illuminated by Dale and Lewis is pretty good.

u/Wazanator_ · 5 pointsr/learnprogramming

Code Complete is really good if you haven't read it yet.

u/Zidanet · 5 pointsr/dogecoin

You should read The Mythical Man Month. It's quite a good explanation of why throwing money and manpower at software does not fix problems and can significantly increase delay.

There's nothing wrong with a small development team using an agile development method.

u/MmmCurry · 5 pointsr/compsci

Not specific to algorithms or even to CS, but Douglas Hofstadter (Gödel, Escher, Bach, I Am a Strange Loop) touches on many of the logical fundamentals in a relatively layman-digestable manner.

I wouldn't call him easy reading compared to Sagan or Kaku, and don't know a "pop computer science" equivalent to those two, but you definitely don't need a CS or math degree to get through GEB. Whether it's on-topic enough here is definitely questionable.

---

Edit: I haven't read it, but from the description this one by Thomas Cormen looks like it might be close to what you're looking for: Algorithms Unlocked.

"This is a unique book in its attempt to open the field of algorithms to a wider audience. It provides an easy-to-read introduction to an abstract topic, without sacrificing depth."

From the TOC, it looks like it's probably fairly light on math but gets into code or pseudocode relatively quickly. I still wouldn't call it pop-CS, but if that sounds like a fit, maybe give it a shot!

u/NowTheyTellMe · 5 pointsr/UCI

So this is what I would consider the "Core" reading list for anyone interested in programming games. None of this is really game specific though. These are just the fundamentals you need in order to be an effective Software Engineer.

Learn about...

C++ syntax: Programming: Principles and Practice Using C++ by Bjarne Stroustrup

Software Engineering: Code Complete by Steve McConnell

C++ gems: Effective C++ by Scott Meyer

Software Teams: The Mythical Man-Month by Frederick P. Brooks Jr.

Why we love Joel: Joel on Software by Joel Spolsky

Problem Solving: The Pragmatic Programmer by Andrew Hunt

Common Code Solutions: Head First Design Patterns by Eric Freeman

Pearls!: Programming Pearls by Jon Bentley

I'll do a supplemental on this in a few days that dives into specific topics related to engine development. All of this is generic enough that it will help you regardless of what you do. You'll notice that very little here is actually language specific. Almost all of this is about the art of making software and process of working with a team. These 8 books alone will make you think about making software in a whole new way.

u/xsdc · 5 pointsr/sysadmin

Personally, I rarely join these organizations for a few reasons. Mostly I feel that they are frequently out of touch and tend to be idealistic, there are rarely speakers or topics of practical use to someone on the job. I understand that most students don't realize this, but being on the job while attending school it really chaps my tender bits.

That said, I am very interested in a decent professional organization provided it meets some requirements.

  1. My time is valuable, please do not waste it.
    1. I don't mean the schedule has to be completely filled every meeting, or that there should be no time set aside for organization matters; I just feel that a lot of these organizations try to fill the time with banal matters when they have nothing else planned but the "end time" isn't there.
  2. Show me, Don't tell me.
    1. Lectures have their place too, but 9/10 times a practical demonstration is much more informative.
  3. How does this apply to me?
    1. If you want people attending speakers, the topic needs to apply to the audience on a wide scale, which I've seen fall down the tubes. In general this point is followed though in these organizations, but it can't be neglected.
  4. Don't try to sell me your crappy software when I ask questions about how to do certain things
    1. this more applies to the speakers from specific companies that come to my work, however I've seen it happen at organizations like this too. Speaker comes and gets asked question on how the software works, yet spends his entire time marketing his product.
  5. Please do not be fanboys.
    1. I know you think 'software x' is the best thing in the world and 'os y' is the end all be all, but not everyone in the profession feels the same way. An OS agnostic group is the only way to go for these organizations as OS preference is fairly polarizing.
  6. Finally: Plan in advance.
    1. If I have to move my schedule around frequently to attend, I will likely decide it's not worth it.

      Now, to go to the actual question presented; What do young professionals want out of an organization like this? this really depends on who you're targeting, those who are in the field will likely be looking for lectures/presentations on best practices, practical examples of deployments of "the next big thing" and hands on training. Those who are in school for this are looking for cool presentations that validate their choice of career, Crazy speakers ("can you get Bill Gates?"), and the stuff I mentioned first. I'm not saying that a person in the field doesn't appreciate that stuff, but the draw for someone in the field is a bit different.

      Last, but not least: books are a good draw. I could see offering a nice book for all the 1 year members or a month or two long promotion "join and get this book free." I'm not sure the budget for you guys, but it's an idea. It'll be hard to draw young people until you have a decent amount already no matter what though.

      Sorry for the long post

      TL;DR: Skip to the paragraph first word "Now" if you want the answer to the actual question.
u/xbrandnew99 · 5 pointsr/Frontend

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)

u/morihacky · 5 pointsr/androiddev
  1. storing activity references beyond their lifecycle:
    http://www.curious-creature.org/2008/12/18/avoid-memory-leaks-on-android/
    http://www.androiddesignpatterns.com/2013/04/activitys-threads-memory-leaks.html

  2. Using Hashmaps when SparseArrayMaps would have sufficed
  3. This is a heated topic, but using enums is apparently costlier than simple static final variables

    Less specific resources:

  4. See the android developer performance tips page.
  5. While the OP asked for Android specific ones, it's important to know the Java related operations too and for that one only has to look at Effective Java - Joshua Bloch - possibly the best book on Java tips.

    I vehemently disagree with the internal/getter/setter rules mentioned in android developer tips page. I personally use proguard and don't think twice about virtual setters etc. since they most definitely help with clarity
u/illbeinmybunk · 5 pointsr/learnprogramming

I find the Head First Design Patterns book to be really helpful. The code samples are in Java, but for the most part the examples are very readable even if you're not familiar with the language. Most of the good stuff is in the explanations, as opposed to the specific implementations shown in the code samples.

u/dendeigh · 5 pointsr/PHP

Not particular to php, this is a book about refactoring legacy code in general https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052

There are a few chapters about how to get legacy code under tests before refactoring. Some methods unfortunately cannot be applied to php (e.g. php core functions cannot be overriden), but still, I found it pretty useful overall.

u/endre86 · 5 pointsr/learnjava

That is a lousy professor. You want to learn more? Nope, don't think so.

You could find open source projects that are written in java. Or maybe check out the source code for OpenJDK (library implementation).

But better yet, pick up a book. You have the popular book Clean Code by R. C. Martin that covers how to write clean and maintainable code. Or maybe the book Head first: Design Patterns by that covers common designs used to make adaptable and reusable code.

But your professor has one point. You should not get lost into code design when still learning the basics. So remember to focus on what you learn in class! :)

u/resisttheurge · 5 pointsr/reddit.com

It becomes useful to replace concepts such as equivalence relations (and other relations) with symbols in order to facilitate understanding, actually. I'm sure you've used the =, <, >, the greater-than-or-equal-to, or the less-than-or-equal-to symbols before. These symbols allow those that read equations, definitions, or proofs to quickly and unambiguously understand what is being discussed. If you end up studying higher math for a while, you become familiar and comfortable with this style of notation.

Interestingly, notation like this and the thought process it represents is important in understanding the structure of mathematical logic, forms a large part of the basis of automata theory (aka why you're able to enjoy complex technology, like computers), and may hold key insights into the nature of consciousness and sentience itself.

If you've got the stomach for the notation, wide worlds of fascinating information await!

u/digitaldoctor · 5 pointsr/healthIT

You do not need to learn other modalities although understanding the underlying physics and knowledge of cross-sectional anatomy is helpful. Approximately half of all imaging Informaticist do not have a clinical background.

Become involved in imaging informatics (PACS and RIS Administration) at your facility to learn everything you possibly can.

Read everything you can about IHE, DICOM and HL7. Knowledge of rules, regulations and guidelines related to imaging informatics is likewise essential.

Focus on information technology such as obtaining your MCSA (Microsoft desktop and server administration certification), CCNA (Cisco routing and switching certification), VCP (VMware certification) or OCP (Oracle database administration certification). Your local community college may be your best resource.

Knowledge of ITIL, project management (PMP), Six Sigma and software development methodologies (Agile, Kanban, Scrum and waterfall) is essential. Arguably, these are the most essential skills for imaging informaticists.


The job market for imaging informaticists is highly competitive but highly lucrative. A highly skilled imaging informaticist can earn over $200,000 per year although I understand that the average is approximately $80,000 per year (from $60,000 per year for a junior imaging informaticist in Asheville, North Carolina to $140,000 per year for a senior imaging informatics in Stanford, California).

https://www.abii.org/About-PACS-Administrator.aspx

https://www.abii.org/docs/Certification-Guide.pdf

http://siim.org

http://siim.org/?page=ciip_study_resources

http://siim.org/?page=pii_textbook

http://www.otechimg.com

http://ihe.net

http://ihe.net/Resources/upload/ihe_radiology_users_handbook_2005edition.pdf

http://medical.nema.org/standard.html

http://www.hl7.org/implement/standards/index.cfm?ref=nav

http://www.hhs.gov/ocr/privacy/hipaa/administrative/privacyrule/index.html

http://www.hhs.gov/ocr/privacy/hipaa/administrative/securityrule/index.html

http://www.hhs.gov/ocr/privacy/hipaa/administrative/enforcementrule/hitechenforcementifr.html

http://www.fda.gov/Radiation-EmittingProducts/MammographyQualityStandardsActandProgram/default.htm

http://www.acr.org/~/media/AF1480B0F95842E7B163F09F1CE00977.pdf

http://www.acr.org/~/media/3E08C87AD6E6498D9E19769E5E5E390D.pdf


http://deckard.mc.duke.edu/pdf/Samei-TG18.pdf

http://www.amazon.com/Practice-System-Network-Administration-Edition/dp/0321492668

http://www.pmi.org

u/h3st · 5 pointsr/programmingcirclejerk

>> I'll give you an example that I paraphrased from Code Complete, which, if you haven't heard of it, is one of the absolute classic works on the topic of how to construct good code. What do you think this code fragment is doing:

>> a = a - b;
>> c = d + sales_tax(d);
>> a = a + late_fee(e, a) + c;
>> a = a + interest(e, a);

>>Despite the good function names, it's still extremely difficult to figure out what this code is trying to accomplish; if I have to make a change in something that relates to this module, I don't know where to start. But, after we name the variables:

>> balance = balance - last_payment;
monthly_total = new_purchases + sales_tax(new_purchases);
balance = balance + late_fee(customer_number, balance) + monthly_total;
balance = balance + interest(customer_number, balance);

>>See how much easier it is now to see that this code is computing a customer's bill based on their outstanding balance and a set of new purchases from the current month?

>>Using good variable names allows anyone to just read your code and understand immediately what it is doing. Without good variable names, anyone reading your code has to already know what it is doing.

>To me the two samples of code are identical except the second is more frustrating because I have to tear through unnecessary characters to see what is really happening with the operators. Maybe if the variable names were extremely short I could better understand your position, but in your example they are not.

>It takes all of 10 seconds to get a handle on the first set of code. I would have to sit down and really study the second set, because its syntax is so completely less apparent. To me tldr sums up my thoughts completely on your second set of code. I guess I can see why that code would make more sense to you, but typically I don't have that kind of time and with big names like that I can imagine my frustration would increase in proportion to the increasing underlying code base. This frustration is just in reading the code. I believe the second code sample likely took you far longer to write than the first.

>I never got into programming to read novels or dissertations.

\>I never got into programming to read novels or dissertations.
master troll

u/EllipsisUser · 5 pointsr/java

The Pragmatic Programmer: From Journeyman to Master

It's not really focused on Java or any language specifically, but it helps you become a better team member. The concepts help you write code you won't curse at later...

u/lofi-coder · 5 pointsr/learnprogramming

Theres a book callee HTML/CSS HTML and CSS: Design and Build Websites https://www.amazon.com/dp/1118008189/ref=cm_sw_r_cp_apa_i_WwD1CbAZFSF55

u/CharlieBlix · 5 pointsr/askscience

You should give this book a read Code: The hidden Language Of Computer Hardware and Software By Charles Petzold

It does a great job of explaining how it all works. Loved it and I don't know how to program (Yet).

u/spitfyre · 5 pointsr/learnprogramming

I used Head First Java. It's actually a pretty funny book and helped me get all the OO concepts down really well. Very easy read.

u/periphrasistic · 5 pointsr/OSUOnlineCS

Hmm, I had a very different impression: I thought that Architecture & Assembly and Networks were the two best courses in the program, that Data Structures, Algorithms, and Operating Systems would have been among the best had they been taught a little better (for the former) or were more rigorous (for the latter), and that the Software Engineering courses, along with Web Development, Databases, and Mobile/Cloud were the worst courses in the program.

For SE I, the primary problem, as I saw it, was that the information was either badly out of date, or covered in such cursory depth as to be useless. The course is heavily based upon the optional textbook, and if you actually read the textbook, you'll quickly discover that the overwhelming majority of the research being cited and presented is from prior to 1990, and hardly any of the citations are from after 2000. Likewise, the course focuses heavily on software development process models, specifically Waterfall and Extreme Programming. However, neither process is particularly popular in the 2016 job market; most organizations at least nominally use some form of Agile methodology, but generally not particularly well. In any event, the process model used by your organization will likely be something you learn on the job. Finally, the course almost completely ignores issues of coding style and writing code that can be easily understood by other developers (which is an entirely different skill than writing code which will pass a grading script), and the sections on system design and object-orientation, which should be the heart of a software engineering course, are entirely cursory. SE I is sadly a required course, but if you actually want to learn software engineering, you are far, far better served by carefully reading Robert Martin's Agile Software Development and Clean Code.

The less said about SE II, the better. That course is a disorganized mess and OSU should honestly be ashamed to charge money for it (the bulk of the course content, in terms of lecture time, consists of links to two free Udacity courses).

u/Eligriv · 5 pointsr/learnprogramming

The trick is training as you go. Like 10-30min everyday, a morning routine before opening your emails, or something like that.

Choose an exercise (/r/dailyprogrammer or any code kata) and try resolving it during your timeboxed training session. At the end of the session, delete your code, and start again the next day.

Each time, focus on one aspect of the code : clean code, unit tests, object calisthenics, etc..

After a few times, when you can solve the problem with your eyes closed, pick a new one.

When you like what you did, put it on your github account and show it to other people (like on reddit or your lead dev etc)

Some resources :

u/wirther · 5 pointsr/learnprogramming

I actually never considered speed when thinking about best practice, so that's an interesting thing to keep in mind as well.

But yeah, one thing I forgot to mention is that I've been reading the book Clean Code, and so far, your solution fits in much better with the conception of best practice that I've learned from that book than all of the solutions voted best practice on codewars. Like I went into codewars thinking to minimize writing lines that do more than one thing, and to try to avoid cryptic syntax as much as possible, but that's the exact opposite of what codewars has been telling me is best practice so far.

u/TheEverHumbled · 5 pointsr/Unity3D

If you are starting from an amateur background as a developer on C# centric stack, I'd argue that Code Complete has strong to potential to protect against your weaknesses/blind spots than just about any book about software development. It doesn't go deep, but it will introduce you to breadth of fundamentals. Feel free to skim past the ones you are already familiar with.

https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

​

The particular techniques described evolve over time, but the principles endure. e.g. One poster commented of making backups. Tools in the C#/MS ecosystem have evolved considerably, but git based source control is pretty popular tech at moment. Github is popular for hosting source of open source projects - Azure Repos and Azure Devops suite has more depth for larger teams and complex processess.

u/srs_moonlight · 5 pointsr/cscareerquestions

I cannot recommend Clean Code by Uncle Bob nearly enough. I learned about him from his (rather idiosyncratic) videos on the subject, and it literally changed my outlook on writing software, top to bottom.

This might seem hyperbolic, but I can't stress the value of his ideas enough - my old company had access to his videos on our internal network, and the first 5-7 videos became required watching for the entire team I worked on. It was a lot of time to devote to something that wasn't coding, but I really believe it helped even new graduates understand the ideas behind "good code" and how to make clean systems in practice.

Let me know if you have any questions about the what or why of the suggestion.

Edit: In the spirit of PM_ME_UR_PIN_NO, I would also emphasize that there is no royal road to writing perfect code, because there isn't even consensus on what perfect code is. This kind of thing is the part of what we do that is more art than science, but I have yet to see a more effective collection of useful tactics than Uncle Bob's work.

u/bubsyouruncle · 5 pointsr/learnprogramming

I would highly recommend reading Effective Java if you want some more advanced java topics.

u/jonride · 5 pointsr/askscience

If you're interested to learn the basic physicality of a computer, I'd recommend checking out a book by Charles Petzold: "Code: The Hidden Language of Computer Hardware and Software."

https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319

It's easy to read and provides a lot of insight into how circuitry embodies and propagates information!

u/Feroc · 5 pointsr/learnprogramming

I recommend the Clean Code book, it has easy examples for stuff like that.

u/throwaway_veneto · 5 pointsr/italy

Per gli algoritmi, questo è un mattone ma dopo anni lo uso ancora all'occorrenza (tipo spiaccicare piccolo-medi roditori).

u/JonnyRocks · 5 pointsr/csharp

The most important thing to me isn't that someone knows everything about a language but knows how r o code well. I highly recommend - Clean Code: A Handbook of Agile Software Craftsmanship https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_apa_i_8wOwDbEN2SQCM

u/pogotc · 5 pointsr/PHP

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.

u/doubles07 · 5 pointsr/learnpython

The book Clean Code was recommended to me by my manager when I asked about writing more efficient code. The author goes through best conventions of naming/organizing/etc for keeping your code base super clean and legible. Other people also recommended the Pragmatic Programmer, but I haven't had time to get to it.

u/ShadowWebDeveloper · 5 pointsr/cscareerquestions

> "oh yeah, that's just how that goes. If you run those one-off they always fail. You have to run the whole suite to make it work."

REQUIRING A SPECIFIC TEST ORDERING MEANS THEY'RE NOT FUCKING UNIT TESTS... HELL, THEY'RE NOT GOOD TESTS IN GENERAL, EVEN INTEGRATION TESTS SHOULD RUN INDEPENDENTLY (BUT MIGHT TAKE LONGER)

I TRIED TO FIND A GOOD CITATION FOR THIS BUT GODDAMN, GOOD DEVELOPERS SHOULD KNOW THIS SHIT

I SUSPECT CLEAN CODE HAS THINGS TO SAY ON THIS SUBJECT, FORCE IT UPON THEIR EYEBALLS

u/healydorf · 5 pointsr/cscareerquestions

As far as engineering practices are concerned: Clean Code, Clean Architecture. A secure app/arch is one that is well understood long after you've stopped working on it.

DefCon has a reading list:

https://www.defcon.org/html/links/book-list.html

If you're looking for a starting point, I'd suggest The Tangled Web. Web/browser security tends to be a good high-level starting point.

You asked for books, but I'd highly suggest participating in some CTFs.

u/AmaDaden · 5 pointsr/compsci

It depends on what I'm reading. 20 for the average book is about what I can read. I've had things like What Every Programmer Should Know About Memory that I could only do 5 pages at best and things like Head First Design Patterns where I could do 40 or 50

An interesting side note is that I've also been reading books like Thinking, Fast and Slow that basically say that we have a finite amount of mental will power. We can only focus on a difficult task for so long before we run out of steam. The only way we know to improve focus this is by maintaining decent glucose levels. So you might be able to improve your limit by having a snack or breaking for something to eat.

I've also been reading Seach inside yourself. It's book on meditation written by a programmer at Google. I'm hoping to improve my focus with meditation. It might also let you bump up your number number of pages per-day or at least let you settle in to reading faster

u/gtani · 5 pointsr/algorithms

That book has reviewed excellent reviews http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1848000693/. This is the standard text, CLR or CLRS http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/

What you're describing is probably what most people think of as machine learning, data science/mining, and has as much to do with computational efficiencies as it does algorithms' intrinsic behavior.

Also, What programming languages do you know?

Maybe if you look at a cheat sheet http://dlib.net/ml.html and some ML texts (Murphy, Bishop, Barber), those would help (also AIMA by Norvig/Russell)

http://www.amazon.com/review/R32N9EIEOMIPQU/ref=cm_cr_pr_perm?ie=UTF8&ASIN=0262018020&linkCode=&nodeID=&tag=

u/remotelyqueued · 5 pointsr/learnprogramming

I like this book on algorithms

u/Mattakinz · 5 pointsr/compsci
u/dehun · 5 pointsr/cpp
  1. use boost::filesystem instead of direct winapi calls


  2. make good names. It is completly unclear what game function do. And the comment will not replace some nice name. The same for aair.

  3. a lot of constants in code. move them somewhere and make a nice names for them

  4. global variables - pathcontainer. and indexes for operations on pathes?

    Copy(6, 12);
    Copy(11, 13);
    Copy(10, 16);
    Copy(2, 3);
    Copy(4, 5);

    This looks like a complete mess.

    Try to read this book and then rewrite this code if necessary
    http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670 this one.
u/maruahm · 5 pointsr/compsci

You're probably right.

For algorithms, the usual undergraduate text is Introduction to Algorithms by Cormen, et al. I do recommend it, too. It's comprehensive and good.

Besides Cormen, I've also made good use of Analysis of Algorithms and Analytic Combinatorics by Sedgewick and Flajolet. They're a bit more advanced, but I don't know algorithms analysis well enough as a field to know where they would usually be taught or how central their material is. They've been very worthwhile purchases for me, though, and I do recommend them as well.

Edit: It's also worth pointing out that, at my institution, the graduate intro algorithms course used Kozen's other textbook, The Design and Analysis of Algorithms. You might want to take a look.

u/serimachi · 5 pointsr/computerscience

It's so great you're being so proactive with your learning! It will definitely pay off for you.

I like other's suggestion of Clean Code, but I fear as a first year that it may have mostly flew over my head--not that it would at all hurt to read. For a first year student specifically, I'd recommend either of two books.

Structure & Interpretation of Computer Programs, also known as The Wizard Book and free on the link I just sent you, is a famous textbook formerly used in MIT's Intro to Computer Science course. However, it's conceptually useful to programmers on any level. If you really, seriously read it and do the exercises, it's gonna give you a rock-solid foundation and shoot you ahead of your peers.

It uses Scheme, a quote-on-quote "useless" programming language for any real-world purpose. That's arguable, but the important thing about the book is that it's really edifying for a programmer. The skill it helps you develop is not the kind that will directly show on your resume, it's nothing you can point to, but it's the kind of skill that will show in your code and how you think and approach problems in general. That said, the book has exercises and the MIT site I linked you to has labs that you could potentially show off on your github.

Code: The Hidden Language of Hardware and Software is much more approachable, is not marketed specifically for programmers, and does not contain any exercises. Read it, though, and you'll find you have a huge boost in understanding the low-level computing classes that your classmates will struggle with. What is basically does is show the reader how one can build a computer, step by step, from the very basics of logic and switches. It's readable and written for a casual audience, so you may find it easier to motivate yourself to finish it.

SICP and Code, despite both being extremely popular, can be a bit difficult conceptually. If you don't fully understand something, try reading it again, and if you still don't understand it, it's fine. Everyone experiences that sometimes. It's okay to move forward as long as you feel like you mostly get the topic. Don't let the perfect be the enemy of the good.

Best of luck to you, and be excited! It's thrilling stuff.

u/MarcMurray92 · 5 pointsr/webdev

Don't Make Me Think by Steve Krug is basically a must read.

This blog post - 7 tips for creating gorgeous UI is a great primer, with lots to think about presented as a few tips focused on aesthetics.

This blog - The Nilsen Norman Group is a great resource for the "functional" end of things, full of tips and research results on what people find the easiest and most enjoyable to use.

u/partybusiness · 5 pointsr/gamedev

I have a web-dev background, so my influences often come from that rather than game-specific stuff.

About Face: https://www.amazon.ca/About-Face-Essentials-Interface-Design/dp/1568843224

The Visual Display of Quantitative Information: https://www.edwardtufte.com/tufte/books_vdqi

Don't Make Me Think: https://www.amazon.ca/Dont-Make-Think-Revisited-Usability/dp/0321965515/

u/cyberbemon · 5 pointsr/hardware

This is a great start, as it explains and goes into great detail regarding cpu/gpu architectures: Computer Architecture, Fifth Edition: A Quantitative Approach

Another one that goes to low level is: Code: The Hidden Language of Computer Hardware and Software

>"He starts with basic principles of language and logic and then demonstrates how they can be embodied by electrical circuits, and these principles give him an opening to describe in principle how computers work mechanically without requiring very much technical knowledge"

-wiki

u/Mattyy_Westside · 5 pointsr/cscareerquestions

Clean Code is also a great book

u/sockmeistr · 5 pointsr/programming

Introduction to Algorithms by Cormen, Leiserson, Rivest and Stein

ISBN 978-0-262-03384-8

One of the few truely good Computer Science books.

http://www.amazon.co.uk/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/ref=sr_1_1?ie=UTF8&qid=1302640399&sr=8-1

u/addcn · 5 pointsr/explainlikeimfive

All of these answers answer your question on a general level, but I would really recommend reading Code: The Hidden Language of Computer Hardware and Software by Charles Petzold for a deeper understanding. He talks about how the first computers were built and how they were programmed, and he does it in a way that's understandable even to a person that doesn't know a thing about computers.

u/mredding · 5 pointsr/compsci

I can't speak of a specific book that is a comprehensive history of computing, but I will speak to books that speak of our culture, our myths, and our hero's.

Hackers and Painters, by Paul Graham. People are polarized about the man, whether he's too "pie in the sky" - full of shit and ego, or if he speaks as an ambassador to our most optimistic ideals of our (comp-sci) culture. The contents of this book is a collection of his essays that are inspirational. It made me forego the societal pressures within our culture and reject popular opinion because it is merely popular and just an opinion, which is a virtue no matter who you are, where you are, or what you do. All these essays are on his website, though. If you want to review them, I recommend Hackers and Painters (the essay), What You Can't Say, Why Nerds are Unpopular, and The Age of the Essay; his oldest essays are at the bottom of the page and go up - he writes about what he's thinking about or working on at the time, so you'll see the subject matter change over time. So much of this will have direct application to his middle school and high school life. I cannot recommend this book, and the rest of his essays, enough.

If he wants to get into programming, I recommend The Pragmatic Programmer. This book talks about the software development process. I'm not going to lie, I don't know when best to introduce this book to him. It's not a hard read whatsoever, but it's abstract. I read it in college in my first months and said, "Ok," and put it down. Approaching the end of college and my first couple years in my profession, I would reread it ever 6 months. It's a kind of book that doesn't mean anything, really, without experience, without having to live it, when he has an obligation to his craft, his profession. I tell you about this one since you're asking about books to tell him, because this isn't something someone would normally come up across without being told about it.

The Cathedral and the Bazaar is a telling book about the cultural differences between the proprietary monoliths like Apple and Microsoft, and the Free and Open Source Software communities that back such popular software as Linux (the most popular operating system on the planet, running on all top 500 super computers, most server computers on the internet, and all Android phones) and Chrome(the worlds most popular web browser). Indeed, this book directly reflects the huge cultural battle that was duked out in the field, in the industry, and in the courts from the mid-90s and into the 2000s. It advocates helping the community, contributing to something larger than yourself, and that none of us are as good as all of us. To paraphrase Linus Torvalds(inventor of Linux) "Given enough eyeballs, all bugs are shallow."

It's important to know who the hero's are in our culture, and they are diverse and varied, they're not just computer scientists, but mathematicians, physicists, philosophers, science fiction writers, and more. I would find a good book on Nicola Tesla, since he invented basically everything anyway (Thomas Edison was a great businessman, but a bit of a tosser), Richard Feynman was a physicist who is still celebrated in his field, and he even worked for Thinking Machines, back in the day, which was a marvel of it's time. Seymour Cray founded Cray Supercomputers and they have a lasting legacy in the field, a biography on that would be interesting. A biography on Symbolics and their Lisp Machines will make him yearn to find one still functioning (a rare gem that crops up every now and again, though he can run one in an emulator), and about the "AI Winter", a significant historic era (note: the AI Winter is over, and we are in spring, the history is both compelling and enthralling). Anything Issac Asimov published (in nearly every category of the dewy decimal system) is also compelling, and hardly dated. In fact, he's the originator of a lot of modern sci-fi. Charles Babbage invented the modern computer (though it was entirely mechanical in his day, and it wasn't actually built until 1996-2002) and Ada Lovelace was the worlds first computer programmer. A woman! Speaking of women, and it's worth young men learning this about our history, Grace Hopper was a military computer engineer who invented the term "bug".

And speaking of women, someone I have respect for, especially if your boy wants to get into game development is Sheri Graner Ray's Gender Inclusive Game Design, which may be more appropriate when he's in high school, and I consider it required reading for anyone who wants to enter the gaming industry. The book lays out plainly how video games hyper-sexualize both women, and, for some reason surprisingly to many - men, it's disastrous effects it has for the game industry, the game market, and the gaming community, and insights on how we may combat it. I have seen colleagues (men) become indignant and personally offended at reading this book, but were absolutely humbled when they took the fight to Sheri directly (we had a few phone interviews with her, always fantastic). If your boy found a problem with this book, he would do well to read Paul Grahams essay on keeping his identity small... The subject matter is not a personal attack on the individual, but on the blight, and he would be better served finding himself on the right side of history with this one, it would serve him well if he were to pursue this craft, specifically, but also any forward facing media in general.

And I also recommend some good books on math. Algebra, linear algebra, calculus, and statistics. You can get very far, lead an entire career unto retirement without knowing anything more than arithmetic and basic, basic algebra, but he could only serve himself well if he makes the decision that he is going to like maths and chooses to willfully become good at it. Outside the context of school and terrible teachers, it's actually an enthralling subject. Just get him a copy of Flatland, Flatterland, and Sphereland. Try this. There are books about proofs that break them down into laymen terms so that anyone can celebrate how special they are. My wife has a few on the shelf and I can't remember their titles off hand. Also this, the book is the narrative of some witty laymen who discover a whole branch of mathematics from first principles, the surreal numbers, an extension of imaginary numbers. It's really quite good, but might keep him occupied for a couple years in high school.

I should stop here or I never will.

u/th3byrdm4n · 5 pointsr/compsci

The Pragmatic Programmer: From journeyman to Master. It's a philosophical book that shares wisdom on how to think like a programmer. . . Not in the pure sense making you a better Computer Scientist (in terms of thinking algorithmically) but if you write code you should give this one a thumb through.

u/Extremophile · 5 pointsr/AskReddit

I think Head First Java is a good book for beginners.

u/ttutisani · 5 pointsr/softwarearchitecture

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.

u/mbizzle88 · 5 pointsr/learnprogramming

Most things can't be classified as universally bad style.

Getters and setters are appropriate for objects that act as data structures (i.e. objects that provide efficient storage of data without other behaviour). They're not appropriate for more complex objects that provide services (such as the BankAccount example given by /u/exoticmatter).

Static methods are useful for making utility or helper methods, among other things. (For example, it would be really wasteful to create a new object every time you wanted to print to the console.) They're generally discouraged in cases where polymorphism would lead to cleaner code.

In short, form follows function. If you're looking for a more in depth discussion of code style, I recommend checking out Robert C. Martin's Clean Code.

u/w3cj · 5 pointsr/javascript

I highly recommend checking out the You Don't Know JS book series by Kyle Simpson. It goes in depth into how the language works and all the quirks you might encounter: https://github.com/getify/You-Dont-Know-JS

If you'd like a shorter read and maybe have your opinions formed for you... checkout JavaScript the good parts: https://www.amazon.com/_/dp/0596517742

u/kraftvgs · 5 pointsr/javahelp

For the love of god find someone else that teaches Java at a high school level. Go over their lesson plans with them. Figure out what types of things they are teaching through each unit. While reading Head First is a good introduction to programming Java, it isn't necessarily what you need to be teaching these kids at this point.

Is this a first programming class for most? Or is this a follow-up to an introductory class? There are a lot of variables that will influence the content and concepts that should be taught.

Finally, and please don't take offense to to this, but I find it crazy that they are having someone with NO experience in the position of introducing people to a field that can be simultaneously fun, frustrating, rewarding, difficult, etc. Again, please don't take offense, but you will not do a good job grading as you have no experience. You need time to practice identifying good and bad code yourself. For every problem out there you can probably devise hundreds of ways to successfully solve it, but only some of them will be elegant and (hopefully in a teacher's eyes) acceptable.

For the love of god take a programming class! Have someone look at code you are writing because there is no better way to learn than to do it yourself. Head Start is a decent point to learn Java. Also check out Clean Code as it will help you learn some fundamentals of what makes good code. Finally, get together with another teacher that has experience teaching this subject matter and leech as much as you can off of them. Software programming can be a fun and very lucrative career. I understand you are lazy but please don't sour kids on it or start them off on the wrong foot.