Best software development books according to redditors

We found 2,146 Reddit comments discussing the best software development books. We ranked the 364 resulting products by number of redditors who mentioned them. Here are the top 20.

Next page

Top Reddit comments about Software Development:

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/samort7 · 257 pointsr/learnprogramming

Here's my list of the classics:

General Computing

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/_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/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/bigwow000 · 79 pointsr/Games

Literally dozens of studies. Source: Rapid Development: Taming Wild Software Schedules. I don't have the book on hand anymore, but I only read half of it, and there are endless studies over decades sources and analyzed. The science universally shows that crunch is counter to productivity.

u/username-proxy · 51 pointsr/learnprogramming
u/Rizzan8 · 46 pointsr/learnprogramming

Here below is my copy pasta of C#/Unity stuff which I post pretty often on /r/learnprogramming and /r/learncsharp . I only need to find a moment one day and add some computer science theory links.

Free C# ebook

http://www.csharpcourse.com/ <- The download link is under 'here' at the end of the first paragraph.

Youtube tutorials:

https://www.youtube.com/playlist?list=PLGLfVvz_LVvRX6xK1oi0reKci6ignjdSa <- apart from C# this dude has also A LOT OF other tutorials on many other languages.

https://www.youtube.com/watch?v=pSiIHe2uZ2w <- has also pretty good Unity tutorials.

https://scottlilly.com/build-a-cwpf-rpg/ <- learn WPF (desktop application with GUI) by making simple RPG game.

https://www.youtube.com/user/IAmTimCorey <- This guy is also good, but I dislike his coding style and that he uses a lot of nugets instead of writing stuff himself.

Book reference guide:

https://www.amazon.com/C-7-0-Nutshell-Definitive-Reference/dp/1491987650/ref=sr_1_1?ie=UTF8&qid=1547990420&sr=8-1&keywords=C%23+in+a+nutshell <- But treat is as a language reference guide, not a programming learning guide.

Text-based tutorials

https://www.tutorialspoint.com/csharp/index.htm <- C#

https://www.tutorialspoint.com//wpf/index.htm <- WPF (GUI programming)

Udemy - wait for $10 sale which occurs at least once in a month:

https://www.udemy.com/csharp-tutorial-for-beginners/ <- for C#, dude has also more advanced tutorials to choose from.

https://www.udemy.com/user/bentristem/ <- for Unity

Do not move to Unity or WPF before you get good grasp on C# syntax and OOP concepts. Bear in mind that majority of Unity tutorials present abysmal C# coding style and practices. So I wouldn't recommend learning C# from such courses.

Coding style (read after getting good grasp of OOP concepts)

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship-ebook/dp/B001GSTOAM/ref=sr_1_1?keywords=clean+code&qid=1562330510&s=gateway&sr=8-1 <- Clean Code, recommended for every newcomer at my work

https://www.amazon.com/gp/product/B075LRM681?pf_rd_p=2d1ab404-3b11-4c97-b3db-48081e145e35&pf_rd_r=22NFZ5GCWM7YMK2A5A2G <- Clean Architecture

u/Nezteb · 43 pointsr/compsci

Some book recommendations:

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/Hyru · 39 pointsr/programming

Books

u/JuanPabloElSegundo · 36 pointsr/cscareerquestions

I read The Clean Coder: A Code of Conduct for Professional Programmers and it introduced quite a few different concepts and lines of thinking for devs. Good read.

u/gvwilson · 35 pointsr/programming

A shorter (and better) version of the talk is online at http://software-carpentry.org/4_0/softeng/ebse/. If you want to keep up with the latest in empirical studies of programming, check out http://www.neverworkintheory.org/ (where we're blogging once or twice a week about recent findings), or have a look at our book "Making Software" (http://www.amazon.com/Making-Software-Really-Works-Believe/dp/0596808321) which collects the most important findings, and the evidence behind them.

u/geek_on_two_wheels · 33 pointsr/csharp
u/Chaseshaw · 32 pointsr/learnprogramming

honestly, pick up this book. it'll up your professionalism a great deal. part of the responsibility of a good coder is to be able to push back to management. not rudely, but they make their money decisions based on tech they don't know, and it's your job to make sure they understand what's possible and what's not instead of just rolling over and taking it.

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/Avinson1275 · 29 pointsr/gis
u/ben9801 · 29 pointsr/todayilearned

So make a project, that's how I learned ios dev. Think of a project you want to do and work on it bit by bit, learning along the way.

Also cookbooks are great for exactly this; they outline a project and post the complete code along with a bit of instructions as to what is being done and why.


Here is a textbook that can really help, you can find it for free 'online':
http://www.amazon.ca/Python-Cookbook-David-Beazley/dp/1449340377

Also the 'learn python the hard way' text is only something like 300 pages and gets pretty extensive with the projects towards the end.

u/trimbo · 28 pointsr/programming

Yep. It's been a while, but I think the process you're talking about is all documented in Rapid Development from when McConnell was at Microsoft. I think it was called "Spiral"?

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/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/hrastignac · 28 pointsr/learnprogramming

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

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/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/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/sleepbot · 24 pointsr/AcademicPsychology

For a stats program, I recommend learning R. It's free and powerful. No need to worry or wonder whether your university will have a license, as you would for SPSS, SAS, STATA, etc.

If you really have no stats background, you might find Andy Field's popular book series Discovering Statistics to be a good place to start. He's re-written this for several stats programs, but you'd want the one called Discovering Statistics Using R. That should be plenty to keep you busy. If not, then go a bit more into factor analysis, structural equation modeling, and Bayesian statistics.

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/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/cfors · 22 pointsr/datascience

Designing Data Intensive Applications is your ticket here. It takes you through a lot of the algorithms and architecture present in the distributed technologies out there.

In a data engineering role you will probably just be munging data through a pipeline making it useful for the analysts/scientists to use, so a book recommendation for that depends on the technology you will be using. Here are some of my favorite resources for the various tools I used in my experience as a Data Engineer:

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/dragonmantank · 20 pointsr/learnprogramming

For all the posts that will eventually come, PHP is a viable language to learn. I'm not saying it's the best language, nor a language that I would point to as an example of "this is how all programming should be done", but there's one big thing PHP has going for it:

For The Web, It Gets Shit Done

So, really, stop with the hate.



As for learning PHP, don't start with a framework. Learn core PHP first and then pick a framework. You'll have a better understanding about what is going on.

Join a local user group. Even if you can't make it to meetings, most of them have newsgroups that you can post questions to and get local advice. Check out http://www.zend.com/en/community/local-php-groups to see if there is one near you.

If you're not on Twitter, get on there to follow big names in the community. @calevans, @lornajane, @weierophinney, and @grmpyprogrammer are a few to follow.

Resources for help that aid in learning PHP:

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/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/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/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/usernamesarethebane · 18 pointsr/java

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

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/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/[deleted] · 18 pointsr/netsec

It really depends on what niche you're looking on covering. It's difficult, I feel, to brush up on "infosec" to any level of practical proficiency without focusing on a few subsets. Based on your interests, I would recommend the following books.

General Hacking:

Hacking Exposed

The Art of Exploitation

The Art of Deception



Intrusion Detection / Incident Response:

Network Flow Analysis

The Tao of Network Security Monitoring

Practical Intrusion Analysis

Real Digital Forensics


Reverse Engineering:

Reversing: Secrets of Reverse Engineering

The Ida Pro Book

Malware Analyst Cookbook

Malware Forensics



Digital Forensics:

File System Forensic Analysis

Windows Forensic Analysis

Real Digital Forensics

The Rootkit Arsenal


Hope this helps. If you're a University student, you might have access to Safari Books Online, which has access to almost all of these books, and more. You can also purchase a personal subscription for like $23 a month. It's a bit pricey, but they have an awesome library of technical books.

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/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/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/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/rockstar_artisan · 15 pointsr/programming

Can't speak for the whole subreddit, but my personal hatred towards him comes from Martin being a snake-oil salesman.

Take his 3 "laws of TDD". Advertised as a practice equivalent to doctors washing their hands, results in horrible and unmaintainable test suites (I've seen plenty of tests whose idiocy couldn't be explained other way than those rules)

Take his "architecture" lectures. Advocating programming in ruby on rails while abstracting away everything about rails or the web or the database, or anything you didn't define yourself. In principle to enable testing and be able to run the code outside the web. In practice: https://youtu.be/tg5RFeSfBM4?t=299 The lecturer says that the architecture in practice is "horribly complicated" and that Bob had only a single implementation of the architecture, which he couldn't share. That didn't stop him from continuing with his lectures.

Take his blogposts (an example: http://blog.cleancoder.com/uncle-bob/2017/03/03/TDD-Harms-Architecture.html) Awful strawmans (this terrible architecture i drew is what you propose), cringeworthy writing style (lengthy discussions with made up opposition instead of real one). Unfalsifiable theories: "Is is only programmers, not TDD, that can do harm to designs and architectures.". That sentence is always true, either you succeeded and therfore TDD works, or you failed and TDD had nothing to do with it. No data to backup his claims "TDD works." - well there are plenty of publications that disagree (see chapter 12. of https://www.amazon.com/Making-Software-Really-Works-Believe/dp/0596808321)

Take his SOLID principles. While some of them are well defined and can be applied meaningfully (Liskov substitution principle), the Single Responsibility Principle has definition so weak and useless it's ridiculous.

u/unborracho · 14 pointsr/devops

The Jez Humble / David Farley book on Continuous Delivery is a must read from a standpoint of teams that deliver solutions in an automated way. More oriented towards software developers than operations / IT but really a must read for both types of folks for us to all come together as "DevOps".

edit: Amazon Link: https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912

u/therookie001 · 14 pointsr/cscareerquestions
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/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/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/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/gunshard · 13 pointsr/PHP

Checkout the book PHP Objects, Patterns and Practice by Matt Zandstra, it helped me dive right into OOP after years of procedural programming.

u/sintos-compa · 13 pointsr/programming
u/ashmoran · 13 pointsr/Buttcoin

/u/nickjohnson has it summed up in this comment:

> Does NOBODY write unit tests?

A unit test is not a complicated thing. It takes one small, self-contained piece of code, sets up some situational context, runs the code with parameters set to interesting values, and then checks that certain conditions are met. (Conditions include things like: the correct result is returned, certain messages are sent, certain messages are not sent, the result is returned in less than X seconds, or whatever.)

It is important to note that while unit tests are not complicated, this does not mean they are not difficult to write. It is somewhere between art and science to write good unit tests, but it is possible. There is something like 20 years of work in this field, especially since the (capital A) Agile movement started. There are whole books on the subject, such as Kent Beck's effortlessly enlightening Test Driven Development: By Example.

Unfortunately, the number of programmers is growing so fast, that new programmers are joining the field faster than they can encounter experienced programmers, and so they are relearning lessons that were first learnt when they were still young, or even before they were born.

This problem didn't used to matter so much, but the situation has changed. Now that people know how to create money with code, code quality is not just a matter of late-night bug-fixing to get a small app released on time, it could potentially make or lose the entire net worth of a person, or even millions of people.

This is exactly the reason I've never bought a single ETH token. When I saw Etheruem, I said exactly this: "It seems to combine the properties of Bitcoin and OpenTransactions in the riskiest possible way". Some time later, The DAO showed the potential downside of that risk.

This kind of problem will not be fixed by developers learning how to write unit tests, it needs a bigger picture than that. But we will be able to put a lot of the world's wealth to much better use, if the developers of cryptocurrencies are able to find and reuse the learnings of software developers in other fields. And as Nick suggested, writing unit tests would be a good start.

u/ibsulon · 12 pointsr/webdev

I'm available for $140/hr. ;)

Honestly, there is more than one right way, and it depends on your particular architecture. However, there are a few obvious ones, and I apologize if I'm insulting your intelligence:

  1. There must be an automated process to build artifacts.
  2. Deployment-specific details must live outside the source code. (IE server locations, database details) - These details can be picked up from properties files or the environment, depending on your system.
  3. Every build must be built by a CI server. A great free one is Jenkins. The build must pass tests every time. It must be deployed to a development or staging server automatically.
  4. Ideally, the same process should take you to production, but it depends on the environment. Either way, it must be completely automated. I know places that have many servers. They do the automatic deployment to 10% of servers, watch what happens, then finish the deployment, but it's all automated.

    From there, it's details.

    http://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912 is a bit repetitive, but it is "the book" for figuring out the right way.

    As for the time to implement it, it's a bit of a virtuous cycle. The more you automate, the more you have time to automate.
u/ap0x · 12 pointsr/ReverseEngineering

Chapter 3 - Windows fundamentals; Secrets of Reverse engineering by Eldad Eilam should be an easy high level overview of the subject. The rest of the book is a great resource too.

u/soadapop · 12 pointsr/PHP

Check out this online book, it covers a wide array of PHP topics, but there are some solid chapters on objects including the building of a basic OOP website.

The book, PHP Objects, Patterns, and Practice is an incredible resource of PHP OOP concepts and application design. It starts off with a few chapters on the basics of OO PHP coding, giving you the rundown of syntax and inner-workings. From there it covers popular OOP design patterns (MVC, Adapter, Component, etc) and then lives up to its name by showing the patterns in practice.

After you've picked up the basics of OOP, check out a PHP web framework. I would recommend CodeIgniter for its amazing documentation, not to mention this wonderful set of video tutorials CodeIgniter from Scractch featured on Nettuts.

Once you get a working knowledge of a framework and have built some basic applications and websites, take the time to study the code behind the framework. Find out where the entry point is and trace its execution, checking out the source for each and ever object that is instantiated. Not only will you pick up on some sweet OOP concepts, but you'll gain a great understanding of how a typical OO PHP application is structured.

Good luck and have fun!

Keep your programs DRY! (Don't repeat yourself) In procedural, you would take those large blocks of code and faction them up into functions. With OOP, look even more abstractly and take several large blocks of related code and put them into classes, which are, at a very basic level, a collection of related functions and properties.

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/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/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/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/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/iprobablydisagree · 11 pointsr/programming

You should read Clean Code.

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/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/bshacklett · 11 pointsr/git

It seems as though you're focused on a particular method for your deployment strategy right now and it may be useful to take a step back and see if your requirements have already been met by recommended patterns.

What you're describing in the above is an integration workflow, and there are many well tested strategies already out there for integrating code (depending on your language/framework, this work may already have been done for you). Most importantly, these strategies rarely suggest cyclical actions like your FTP^(*) transfer from html back to "Remote1".

Ideally, you want your flow to look something like the following:
git repository -> integration steps -> build -> build artifacts -> artifact repository -> deployment tool -> deployed code

Note how this is a unidirectional flow, with nothing being pushed back into the Git repo. You may need to pull artifacts in from multiple build pipelines depending upon your requirements, but if you see the flow being reversed (committing back to git), you should carefully consider why you're doing so and ensure that there's not a better solution^(†). Additionally, while you may very well not need some of the previously listed steps, you should understand what each of them is and make an informed decision about whether or not it should be included.

I would strongly recommend spending some time diving in to Continuous Integration and Continuous Delivery/Deployment (CI/CD) and the patterns used within those methodologies, keeping in mind that CI/CD does not start with automation, but with understanding your code and requirements. One book I would strongly suggest is Continuous Delivery by Jez Humble and David Farley (https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912). It's starting to show its age a bit, but the fundamental ideas are still there and there's a lot of value to be gained from reading it.

Focus your reading on the what and the why before you move on to the how. There are tons of articles out there on how to build fast and efficient CI/CD pipelines, but if you don't have a solid understanding of why the pipeline should be there in the first place and what value it adds, it's easy to see articles of this nature as pointless exercises or end up building something that doesn't really fit your requirements.

​

* This is a warning sign, by the way. If you find yourself thinking that FTP is the solution, consider it a red flag; step back and re-evaluate.

† There are some common patterns which result in committing code back to a git repository, but they solve rare use cases and tend to generate a significant amount of debate. In particular, some say that generated code should be committed back to a repository. As an alternative, I would suggest considering generated code to be a build artifact and storing either it or resulting binaries in an artifact repository rather than trying to commit back to git.

u/FetchKFF · 11 pointsr/devops

You've got a lot of foundational knowledge to pick up if you're going to successfully complete this. And fair warning: for people with excellent domain knowledge, the task ahead of you can take months. My suggestion would be to read the following resources, to figure out what extra knowledge you need from there.

Jez's book on Continuous Delivery - http://www.amazon.com/gp/product/0321601912/

Paper on CI with Docker - https://www.docker.com/sites/default/files/UseCase/RA_CI%20with%20Docker_08.25.2015.pdf

Pattern of CD with New Relic - https://blog.newrelic.com/2015/03/06/blazemeter-continuous-delivery/

CI/CD in the web development space - https://css-tricks.com/continuous-integration-continuous-deployment/

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/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/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/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/dgryski · 11 pointsr/programming

It is an academic paper and written as such. For a more practical approach to the topic, try some of these:

Programming Pearls

Performance Bugs

Performance Engineering of Software System

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/bot_bot_bot · 10 pointsr/learnprogramming
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/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/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/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/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/_EvilRin · 10 pointsr/pcgaming

A lot of these people have university degrees or better knowledge about ASM and dissecting than your university professors. Do you really believe people without qualification could beat a software solution of a multi-million dollar company that's sole propose is to protect software (VMProtect and Denuvo), that employs security researches and experts with 10+ years experience in the field and did years of development on said DRM? You sound like you don't have the slightest idea about the amount of brain power that goes into reversing something that doesn't want to be reversed. Maybe educate yourself before drawing conclusions.

u/jeremywilms · 10 pointsr/hacking

Depending on the sort of hacking you want to do, your programming skills will likely complement your learning experience very well.

Depending on what sort of programming you've been doing and what your target is, it could also be totally irrelevant.

If you're looking to find exploits in software (i.e inside of a server) you'll need to understand how to reverse engineer it and search for exploits - getting a hang of IDA Pro and OllyDbg will be key to this. If you're looking for software exploits, already understanding languages like C and C++ will be highly benificial. Understanding your target's platform will also be crucial.

If you want to get into exploiting websites etc your C programming probably won't be too helpful - since most scripts are most easily hacked up in python or php. If you have any experience in programming server-side logic in php and interfacing with databases then that would be applicable to this field.

As I am more into native software reverse engineering and not hacking webservers I can really only point you down the path of reverse engineering software. A very good book I found for this was http://www.amazon.ca/Reversing-Secrets-Engineering-Eldad-Eilam/dp/0764574817

This book will guide you through the process of offline and online analysis with ollydbg and IDA. Further it will introduce you to the internal workings on the windows platform (which is crucial if you're looking to reverse engineer targets on the windows platform.)

There are some good books on IDA Pro as well.

u/Monory · 10 pointsr/GradSchool

I've really enjoyed Discovering Statistics using R by Andy Field. The book is written more like prose than a textbook, and is rarely dry. It requires you to learn how to use the R programming language as well, but I think it is very worth it. Everything he teaches, he teaches it at the conceptual level first and then shows you how to perform the tests using R. A great bonus is that R is great for data visualization, and being able to visualize large data sets quickly really helps get a better understanding of the data you are working with, which helps learn the theory.

u/cpp_is_king · 9 pointsr/gamedev

Yea, I actually recommended one in the post above. Here's a direct link though

I'm recommending this only because it's the one book on the topic that I've read and it was really good. There's others too, like this one, but I haven't read them so I can't comment.

Any book about reverse engineering can only teach you the most basic things. But it teaches you enough that once you're on your own, you aren't lost. If you want to develop the skills further, just start disassembling OS functions and figuring out how they work.

Another book that's tangentially related is this one. It isn't about reverse engineering specifically, but rather about debugging (usually without source code), which is obviously a critical skill.

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/woodforbrains · 9 pointsr/AcademicPsychology

An EXCELLENT response. I'm a research psychologist and I think that is an absolutely fair summary of what to expect if you go the grad school route.

As far as "what you're expected to know", this will vary by which of the four options you choose; the best RAs i've mentored are always interested in two things: stats and current literature. Google Scholar your favorite topic in psychology and the backwards/forwards links will connect you to a wealth of ideas. As for stats, they get a bad rap, but i can suggest a few books that might turn around anyone with stats-loathing:

-Andy Field's SPSS/R how-to books. Honestly, the man has probably done more for beginning psychologists than Starbucks. Very readable, even good for more developed psychologists to get ideas for new analyses.
http://www.amazon.com/Discovering-Statistics-Using-Andy-Field/dp/1446200469/ref=sr_1_2?s=books&ie=UTF8&qid=1419965487&sr=1-2.

-Mac & Creel: Bible for signal detection theory, a cool way of thinking about perception as a process of separating signal from noise.
http://www.amazon.com/Detection-Theory-A-Users-Guide/dp/0805842314

u/trngoon · 9 pointsr/statistics

You must learn an application heavy book in 2018. Preferably in R unless you can program, in that case maybe Python.

I will link you two perfect books with very little math that people from any discipline can understand and are very well written. Both heavy on application in R with accompanying websites with all the code. (dont worry, R code is easy and the vast majority of R users are not programmers in the traditional sense). The first book I link does go into some more advanced topics, but everything is explained in a very common language. Its accompanying website also has lecture videos from the prof who wrote it.

https://www.amazon.com/Discovering-Statistics-Using-Andy-Field/dp/1446200469

^^ I emailed andy some time ago and he wants to release edition 2 next year probably

https://www.amazon.com/Understanding-Applying-Basic-Statistical-Methods/dp/1119061393

Trust me, these two books are what you want to look into.


NOTE some idiot is going to try to suggest to you a book called "Introduction to statistical learning" (mainly a supervised machine-learning book which is stats-focused) by the standford stats team. Do not start with this book if you want to learn traditional stats (like you point out in your post). No one who recommends you this book has considered your needs. I see this recommended every single day for all the wrong reasons. It actually makes me frustrated. It's a great book but has confused many people because of its name. Is it a stats book? Yeah. Is it an ML book, yeah? Is it a traditional stats book? Nope. Anything that says "_____ learning" is probably a machine learning book. Sorry for the rant.

u/arsenalbilbao · 9 pointsr/learnpython
  1. if you want to LEARN how to write programs - read "Structure and interpretation of computer programms" on python - SICP (project: you will write an interpreter of "scheme" programming language on python)

  2. if you want to TRAIN your OOP skills - Building Skills in Object-Oriented Design (you will code 3 games - roulette, craps and blackjack)

  3. Helper resources on your way:
    3.1. Dive into python 3 (excellent python book)
    3.2. The Hitchhiker’s Guide to Python! (best practice handbook to the installation, configuration, and usage of Python on a daily basis.)
    3.3 Python Language Reference ||| python standard library ||| python peps

  4. if you want to read some good python code - look at flask web framework (if you are interested in web programming also look at fullstackpython

  5. good but non-free books
    5.1. David Beazley "Python cookbook" (read code snippets on python)
    5.2. Dusty Phillips "Python 3 Object Oriented Programming" (learn OOP)
    5.3. Luciano Ramalho "Fluent python" (Really advanced python book. But I haven't read it YET)

  6. daily challenges:
    6.1. r/dailyprogrammer (easy, intermediate and advanced challenges) (an easy challenge example)
    6.2. mega project list

  7. BONUS
    From NAND to tetris ( build a general-purpose computer system from the ground up) (part1 and part2 on coursera)
u/WellThenScrewIt · 9 pointsr/ReverseEngineering

Learn to write simple C programs. Then debug your own C programs, preferably in OS X or Linux using gcc/gdb. Then disassemble your own C code (learn how to disable optimization in the compiler; try it with no optimizaiton and then with increasing levels). Then look at C++ and (gasp) Visual BASIC and such. Turns out a ton of malware is written in these languages, and the snarl of garbage that you'll uncover that is just part of the auto-generated message handling stuff for VB will astound you, so don't start there...but it's important to understand those structures when you see them.

Then follow tutorials about reversing other programs. There are great books on this.

It helps a lot to know assembly language, but you'll tend to pick it up as you go.

You'll want better tools than just command-line disassemblers. I prefer IDA Pro.

There's a great book that uses IDA Pro with many examples to address precisely your questions.

Here's another great book on malware analysis that covers all kinds of tricks you might bump into when working on real targets.

I see all this as a long-term iterative exercise. It's fascinating.


u/jodevgn · 9 pointsr/csharp

I found this book to be incredibly helpful: https://www.amazon.com/Art-Unit-Testing-examples/dp/1617290890/ref=sr_1_1?ie=UTF8&qid=1500721325&sr=8-1

It's not so much about Test Driven Development, but focuses more about how to organize and write unit tests and fakes. Has a lot of discussions pro and con regarding things you may run into. It also compares unit testing frameworks. Keep in mind that the book is over three years old now, so those comparisons may or may not hold up as well anymore. Doesn't detract from the rest of the book though.

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/0b_101010 · 9 pointsr/learnprogramming

Hi! I recommend the following books:

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/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/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/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/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/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/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/fesor · 8 pointsr/PHP
u/MoonShadeOsu · 8 pointsr/ProgrammerHumor

Sounds like you need this.

Good luck!

u/logan_capaldo · 8 pointsr/programming

Martin Fowler did not write Working Effectively with Legacy Code, this guy did.

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/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/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/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/smo0shy · 8 pointsr/MrRobot

I actually already have a copy of Hacking: The Art of Exploitation. My personal library consists of around 45 books on a range of computing topics from PHP, MySQL, C++, Windows Internals, CCNA, MCSE/MCSA, Unix, Rootkits, AI, Data Structures and the list goes on.

Other relevant titles include Gray Hat Python, Reversing: Secrets of Reverse Engineering and Rootkits: Subverting the Windows Kernel.

I was going to buy the following: Assembly Language Step-by-step, SQL Injection Attacks and Defense and Metasploit: The Penetration Tester's Guide.

I agree that where one starts really depends on what they want to end up doing. "Hacking" is such a general term and SQL-Injections is completely different from finding 0-days. If I'm honest I'm not sure where to start but I'm open to suggestions.

​

u/thestandardtoaster · 8 pointsr/PHP

PHP the right way is a very good site, but for books one of my favorite in php is http://www.amazon.com/dp/143022925X/ PHP Objects, Patterns and Practice. I never used media wiki but joomlas code base a few years ago was a joke (hope it has gotten better!).

u/lmouelle · 8 pointsr/learnprogramming

Clean code. read it learn it love it

u/wouterla · 8 pointsr/softwaredevelopment
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/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/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/xCavemanNinjax · 7 pointsr/java

It's very difficult to answer your question in a single post. You should know the basics of Java of course but what you will be able to do will be limited by what you know. I suggest picking up a book and using online resources and just jump in, get started! You'll learn along the way.

Book that helped me a lot:
http://www.amazon.com/Professional-Android-4-Application-Development/dp/1118102274/ref=sr_1_1?ie=UTF8&qid=1409582592&sr=8-1&keywords=professional+android+development

and Android development ground zero:

http://developer.android.com/index.html

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/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/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/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/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/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/Novakog · 7 pointsr/compsci

Actually, I've seen quite a few loop invariants in shipping production code. But probably 95% of the times they're used, the programmer might not even think to call it a loop invariant.

Specifically, a lot of codebases use conditional assertions to test for bad conditions (usually debug-only). If you place a conditional assertion in a loop, you're expressing a loop invariant. I personally have used them to find a number of bugs in shipping production code.

Read Programming Pearl's - it's very short classic, and he uses loop-invariants via assertions.

u/mr_chip · 7 pointsr/sysadmin

Some more:

The Art of Scalability - Well, the first 2/3 of it.

Scalability Rules - Very good, very short.

Continuous Delivery (I'd argue this is the single most important book in the software industry in the last 10 years)

The Little Redis Book - Free download!

The Little MongoDB Book - Free download!

The Varnish Book - Available as a free PDF if you fill out a marketing form.

u/deadbunny · 7 pointsr/linuxadmin

Disclaimer, I have zero Ruby experience, I also suck at explaining things.

Cucumber/Aruba appear to be testing frameworks, I have no idea how they work specifically but the general gist of Test Driven Development is you write a test for what the code should do, then you write the code to pass the test (functions as specified), developers write code, run tests, release code (in short).

So assuming they are wanting this formalised by you I am guessing they want some kind of automated testing/continuous integration server. This would essentially be setting up a Jenkins server with a bunch of projects (one per code base) that uses the tests (developer written).

Example:

No CI:

You have a git repo for "project-awesome", (you'll very likely find) developers branch off of master into a feature branch, work on their stuff then merge into master when done, this will then either get packaged up or deployed from git (either manually or by a config management system).

With CI (very basic):

master is the release branch, developers branch off of a development branch do their stuff and push back to the development branch when done, from here Jenkins see the branch has new commits so runs the tests on the code automatically and if they pass merges them into master which then gets deployed, if not it'll fire off an email to whoever committed the code and give them the failed test results.

The aim here is that testing is completely automated which means even if I'm working on feature X but my changes break feature Y it will be caught (in theory) by Jenkins meaning there is a reduced risk of breaking production but pushing bad code.

I just found this page which should hopefully cover some of the general idea better than I can (and it has pictures!), personally I'm a big fan of CI and use it for everything that makes sense (code, scripts, config management states). With that said it's a pretty daunting subject if you have no idea what you're doing (like me most of the time!) and you'll need to do a fair bit of reading and I would heartily recommend this book

u/c3261d3b8d1565dda639 · 7 pointsr/programming

I think posting material like this with no context is silly, but I upvoted this anyway because I recommend these books often. The Introduction is very short and explains better than I could here why the books were written. The quality of the chapters vary, but they are mostly all worth reading. I'm excited for the upcoming The Performance of Open Source Applications, although I haven't heard any news about its progress in a long while.

One of the editors, Greg Wilson, did some research into how we can be effective programmers. Basically, continuing the research that books like Code Complete were based on. He wrote an excellent book Making Software: What Really Works, and Why We Believe It. He is also involved with the community blog It Will Never Work in Theory, which is tag-lined as software development research that is relevant in practice.

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/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/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/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/izut · 6 pointsr/programming

There's a pretty good book that touches the refactoring as learning tool subject: Working effectively with legacy code.

u/MINOSHI__ · 6 pointsr/computerscience

are you talking about this book ?

u/ultimape · 6 pointsr/learnprogramming

The Anti-Pattern###


What you've got here is similar to the "Arrow anti-pattern", but may also be part of the "Redneck conditional" anti-pattern. Its hard to tell without seeing the rest of the code.

Here's an article that covers the redneck pattern. It links to some great resources for fixing the Arrow issue at the end. This Youtube Presentation: The Clean Code Talks -- Inheritance, Polymorphism, & Testing and a pretty good overview on Coding Horror: [Flattening Arrow Code](http://blog.codinghorror.com/flattening-arrow-code/
)


This Is Normal###


I end up with this pattern a lot on my first pass through prototyping a program. Sometimes its faster to write something quick and dirty - generating code as you think of it (redneck conditionals and all), then go back through and pull out redundancies and rework things to avoid !isTrue lines and other less than good code.

I think this has to do with how spoken language needs to be compiled into thought 'just-in-time'. We front-load our conditionals simply because the mind is not good at keeping more than a page full of words running at any given time. Its only natural to think about problems this way.

This is why languages like Perl and Scala appeal to me - it lets you say things like "do this thing, unless that" and sometimes feels like poetry.


Let it Haunt you at Night ###


Never be comfortable with code like this. Good developers strike a balance between writing good code, and shipping code.

Being a great programmer is 90% sweat, and another 90% discipline. Taking pride in your code means you don't release what you've written into the wild unless there is a good reason for it. If you can help it, don't let prototype code become production code. When in doubt, go with the mantra of "fuck it, ship it", but don't sweep bad code under the rug. Ignoring the problem of technical debt will come back to haunt you one way or another..

And remember: "Always code as if the person who ends up maintaining your code is a violent psychopath who knows where you live."

Why It Is Important To Fight It###


If there is never time (or demand) to clean up this awful code, all you end up doing is building up technical debt, eventually leading to the lavaflow antipattern and other more disastrous patterns.

My rule of thumb for keeping things DRY is the rule of three.

Do this enough, and in time you will start to see opportunities to rewrite your code as you do it. Basically you start to think like a programmer and metaphorically 'speak the language'.

What Happens When You Don't###


Fighting this way of programming is what elevates a good programmer to a great programmer.

The truth is that this is the default/naive style that comes out of procedural programming. You can become so good at this style of coding that you become an Expert Beginner
.

These expert Cowboy Coders look amazing to management. They able to sling code around fast and brute force their way through code like a mad man. Many 'expert' programmers, even ones who've been in the industry a long time, fall back on copy/pasting code so often that when they end up copying the same bug through out their codebase they don't even take a second thought. This style of development seen normal to them, and being riddled with bugs is just the cost of doing business.

Entire organizations can find themselves full of these types of programmers to the point that the culture shifts from wanting clean code to one that ends up being little more than a drawn out death spiral.

From my experience, this style of coding is very easy to do in languages like COBOL and FORTRAN and can be the default style in larger codebases that were minted before Structured Programming took hold. This lead to the often quoted line by Dijkstra: "The use of COBOL cripples the mind; its teaching should, therefore, be regarded as a criminal offense.".

This can lead to organizations shooting themselves in the foot and losing their best programmers. The codebase becomes riddled with bugs that seem to be near impossible to stamp out, and the ticket workload becomes so intense that you end up with the Crunch Time organizational anti-pattern just to fight the effects of technical debt. I can't see a self-respecting programmer lasting long in such an environment.


----

I've been trying to find organizations that are passionate about their code quality, and serious about their company culture. If you know of one, please let me know.

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/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/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/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/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/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/gospelwut · 6 pointsr/learnprogramming

I personally thought Pro C# and the .NET 4 Platform was pretty good, but most people would turn you to C# In-Depth simply because it's by Jon Skeet, which is sound reasoning in and of itself.

u/DutchPhenom · 6 pointsr/AskEconomics

Now this is an interesting and difficult question, which depends on many things. For starters, if you find this process frustrating that is unfortunate, because learning how to code is usually a trail and error + revise your work process. In other words, its supposed to be both frustrating and rewarding, like a hard (text-based) video game. For me its half of the fun.

What you want to learn really depends on the context. If you are really diving into econ, Stata is still very common. More stats-heavy, new, or interdisciplinary fields tend to use R. If you work with big, live datasets, or work with computer scientists, learning Python is always a plus. But obviously start with one.

I am proficient in stata simply because I had classes in it, it is difficult for me to advice how to self study. I learned most of the basics through An Introduction to Modern Econometrics Using Stata, and later on most of my R through R for Stata Users (Statistics and Computing) . I also learned some R through Discovering Statistics Using R, but I find Field obnoxiously failing to be funny, so I wouldn't reccomend it.

I'm now in the process of learning more Python, to do some more programming work on the side. As a start I used Learn Python 3 the Hard Way recommended to me by a very proficient friend of mine. This however does not give you much of an intro to stats in python, only the very very simple basics you can use as a vantage point for further work.

If you have learned the basics, tbe hest way to learn more is just to fool around. What is your field of interest? I like a lot of macro, so I used to just go to Quandl, pick some free databases, import them, and run some fun stuff. This is the best way to learn, especially if you for example try to merge free World bank databases with a different database from Quandl, as it will give you a lot of errors whilst merging and conversion problems later on.

If you are a bit more proficient you can start using websites like upwork to get some assignments. Usually it doesn't earn you much at the start, but the experience of actual assignments is the best way to self-teach. A different manner I like to do (if you are still studying) is offering your services (for free) to a professor. Ask him/her if there are still projects they are working on for which they need some to look at. Usually you will be treated solely as someone for the code, but it generally gives you a lot of experience and the right contacts.

These are just some of my thoughts. If you could provide some more context of where exactly you want to go, I could go into more detail.

Edit: What I forgot to say is that if it is not possible to study a course, I would recommend doing at least one MOOC to get you at a basic level.

u/datadude · 6 pointsr/datascience

I have an excellent statistics text book that I am using to learn stats: Discovering Statistics Using R by Andy Field. My approach is to do the exercise in R first, then try to reproduce the same result in Python. It's slow going, but it's a real learning experience.

u/Jake_JAM · 6 pointsr/statistics

I like Discovering Statistics using R . Great book for learning the basics of hypothesis testing, a little bit of math, and you learn how to do it in R; not to mention there are a few bits you’ll chuckle at. There are also other books for other programs in this series (SPSS, SAS).



u/NudeRanch · 6 pointsr/AskStatistics

This book is a amazing:
Discovering Statistics Using R
by Andy Field


If you are doing self-study, it is easy to lose momentum. This book is hilarious, personal, and transcends the textbook genre.

Amazon Link

u/BinMapper · 6 pointsr/Malware

Some resources which will indirectly help you for GREM

https://amzn.com/1593272901

https://amzn.com/1118787315

https://amzn.com/1593272898

u/StuartPBentley · 6 pointsr/bindingofisaac

The best introduction to Lua, without a doubt, is Programming in Lua by Roberto Ierusalimschy (the language's creator). I personally have a signed copy of the second edition.

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/596F75206E65726421 · 6 pointsr/javascript

>What are some good guides/practices to unit testing?

Test Driven Development: By Example is a good book to get started with

>Say I have an app with dozens of functions, how do I choose which functions to write tests for, and are there preferred style guides for these tests?

Ideally, you would test them all and you would want to write unit tests and integration tests for them.

>If it helps I want to begin by testing the front end code, whether it's generated with a framework like React or more bespoke using template strings. How do you conduct "recon" on your code to pick the targets to write tests for first, and how do you choose your testing framework?

I've never used bespoke so I can't comment on it but for React I'd recommend jestand enzyme. Jest is a testing framework that was created by Facebook (the creators of React). It's not specifically designed for React but it works great with it. Enzyme is a library made by Airbnb specifically for testing React components. Enzyme is designed to work along side Jest.

>I know you need as much coverage as possible but since you gotta start somewhere, how do you pick the starting point in your code?

The most critical part of your application

u/itacirgabral · 6 pointsr/brasil

Fui monitor de web na facul. hoje trabalho mais com backend em nodejs. Javascript é a base e sempre vale a pena ter os fundamentos bem sólidos. Gosto deste livro, baixe aqui.

Com githubpages você consegue ir longe e de graça, meio que já é o padrão do desenvolvedor ter o seu portfólio ai. Você faz seu site estático e hospeda nesse lugar. Github é um site que fornece serviço de git, que é tipo um dropbox pra código. Vale muito a pena, dai tu compra um domínio por 40 reais e bota um email nele de graça.

u/steveklabnik1 · 6 pointsr/rust

> there are real studies

have you read http://www.amazon.com/Making-Software-Really-Works-Believe/dp/0596808321 ? It's really interesting.

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/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/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/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/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/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/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/mostlyemptyspace · 6 pointsr/startups

One book I recommend to my CTO friends is The Clean Coder. It really helped me set the culture for how our development team should behave themselves. I bought a copy for everyone on my team.

I also strongly recommend Hooked. If you're at all involved in the product management side of things, this really helped me understand how to build an engaging product.

Many of my fellow CTO's recommend Extreme Ownership. The idea here is that as a startup team, you have to be willing to (figuratively) die for one another, and you have to have each other's back the way a platoon in combat would.

u/IllTryToReadComments · 6 pointsr/learnpython

What I learned from reading Clean Code [1] is that developers spend far more time trying to read/understand code then they do actually writing it, they gave an empirical ratio of 10:1 for the time spent reading vs writing code. So I think it's worth it in the long run to make your code cleaner/understandable for other devs.

I highly recommend the book, they even have an entire chapter dedicated to meaningful names, so I think it's important to refactor variable names as well.


[1] Page 13 in the "We Are Authors" section (you can actually see it in the Amazon preview if you want)

u/Mattyy_Westside · 5 pointsr/cscareerquestions

Clean Code is also a great book

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/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.

u/TracerBulletX · 5 pointsr/iOSProgramming

I spent a lot of time learning specific architectures and patterns that were in common usage when I first started, but the specific patterns in vogue are constantly changing. I'd recommend reading all 3 of these books at some point earlier in your career, I think a lot of the popular software design practices are based on the foundation of ideas in here and if you read them you will start to naturally make the right choices when it comes to organizing your code.

https://www.amazon.com/Pragmatic-Programmer-journey-mastery-Anniversary/dp/0135957052/ref=pd_sbs_14_t_0/142-3028760-3243861?_encoding=UTF8&pd_rd_i=0135957052&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D

https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=pd_sbs_14_t_2/142-3028760-3243861?_encoding=UTF8&pd_rd_i=0735619670&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_sbs_14_t_1/142-3028760-3243861?_encoding=UTF8&pd_rd_i=0132350882&pd_rd_r=8877e123-b48f-4ce7-9e92-fec38cbeb54f&pd_rd_w=CdI3a&pd_rd_wg=arKVG&pf_rd_p=5cfcfe89-300f-47d2-b1ad-a4e27203a02a&pf_rd_r=9JQWC8NFNAY0GN7FAN9D&psc=1&refRID=9JQWC8NFNAY0GN7FAN9D

u/OwlThinkAboutIt · 5 pointsr/learnprogramming

[here is a fantastic book every programmer should read] (https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_apa_kt9TAbN9RY2S3)

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/Feroc · 5 pointsr/learnprogramming

I recommend the Clean Code book, it has easy examples for stuff like that.

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/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/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/Tangurena · 5 pointsr/cscareerquestions

> I absolutely HATE having to go through someone else's confusing uncommented code and figure out what the hell is going on so I can fix some bug. I hate having hours go by where I have nothing external to show for it, even though I have been running a mental marathon trying to figure out what the problem is with the code in front of me.

This is called "maintenance" and is what everyone has to do. If it kills you, then I think you will have a short career in this field. Learn some management skills and get your student loans paid off as soon as possible. Eat ramen and ride a bike in order to do so. If you hate maintenance and " the same boring financial application for a month straight" as much as you say, it will be a race between paying off your loans and quitting the field totally.

You aren't going to remember what you wrote 6 months ago, nor why you wrote it that way. So you are one of the people whose code you will be maintaining. Learn to write meaningful comments because the person you might be saving hours of wrestling with "why did this idiot write it this way" is going to be yourself. The company I work for produces boring financial applications and several of them have been shipping to customers every year for over 20 years. Migrating from one source control system to another almost always loses all the check-in comments, so all we have is the code and the historical changes.

There are 3 books that I think you ought to read:
Brownfield Application Development in .Net is aimed at the .NET stack, but I think is applicable to any framework.

Working Effectively with Legacy Code is about how to approach "legacy code" (whatever you're maintaining) in order to fix bugs and add new features.

The Passionate Programmer is about focusing on your career and how to make it through many of life's hurdles.


Take a look at the reading list I posted on another forum. Many of the books are about how to approach your career and other people in the field.

I've been a programmer for almost 20 years.

u/Blatherard_Osmo · 5 pointsr/webdev

You should take a look at the book "Working Effectively with Legacy Code" by Michael Feathers, which is on exactly this topic. It's about ten years old at this point but still the best.

Here's an amazon link http://www.amazon.com/gp/aw/d/0131177052?pc_redir=1413174357&robot_redir=1

u/antisarcasm · 5 pointsr/programming

What you're saying doesn't make sense. Amazon has had a rating/review system for a very long time. You can access them here. As you can see, the reviews are overall very good and it is probably a good idea to purchase this.

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/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/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/cplusequals · 5 pointsr/politics

Currently reading Clean Code. Highly recommend it to any other software developers.

u/caryy · 5 pointsr/learnprogramming

In addition to Code Complete 2, which, while very dense, is a compendium of wonderful coding knowledge... I recommend Clean Code by Robert C. Martin.

One of the best books on concurrency that I've ever read is definitely Java Concurrency In Practice it's (obviously) written with Java in mind, but most of the concepts map rather easily to constructs in other languages as well.

The standard for design patterns is still probably Design Patterns (colloquially "Gang of Four")... but I've heard good things about Head First Design Patterns as well, despite the really stupid cover.

u/desrtfx · 5 pointsr/learnprogramming

Your friend is wrong. Sure, functions are for code reuse, but they should also be used to make code readable and especially to break down large chunks.

Just give your friend Clean Code by "Uncle Bob" Martin to read. It will completely change his views on code.

---

BTW: The second version of your code is way better, but why did you not go all the way? You still have the crossHairTexture stuff in the constructor. Why did you not also stick this part in a function?

u/wordsoup · 5 pointsr/books

As software engineer there are of several books like Clean Code and in other fields there are probably other essential books.

But your question probably aims at books that convey general knowledge - increasing specifically the capacity of intelligence is very debatable - in this case my answer is The Art Of Learning.

u/Hitthefairway · 5 pointsr/webdev

The Clean Coder: A Code of Conduct for Professional Programmers https://www.amazon.com/dp/0137081073/ref=cm_sw_r_cp_api_i_6rJ6AbTS2DYWA

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/GeneticsGuy · 5 pointsr/wow

Reverse engineering, technically. Blizz doesn't actually publish an official list of available Lua API (which I find odd, personally), but you can find them by looking at memory dumps on each update.

You can also do an /etrace and then see the exact events being fired and thus record anything new. Though, that is a bit inefficient. Blizz often announces UI/Macro changes HERE

If you want to do your own scans to see the latest API check this out here

Some basics on how to do this can be found HERE, though it might be a bit outdated, it is quite good on how to learn for yourself how to reverse engineer programs

u/PeeWeeHerming · 5 pointsr/AskReddit

Reverse engineer Microsoft patches.

edit: serious answer:

I do this kind of work for a living. I started out in 1995 when I was 13 years old learning from mudge's excellent article on how to write buffer overflows and I progressed from there.

If you're analyzing software for which you have access to source code, you can't beat The Art of Software Security Assessment: Identifying and Preventing Software Vulnerabilities.

Chris Wysopal's Art of Software Security Testing is also good.


If you're attacking software for which you have no source code, learn about fuzzing and reverse engineering. An excellent intro to reverse engineering is Reversing: Secrets of Reverse Engineering.

Those will get you started, but it helps to have people around you who are successfully discovering and exploiting software vulnerabilities. This is also the kind of field where you absolutely have to stay on top of the latest developments in software security. Things move at a mind-boggling pace. Read security blogs, talk to people in the industry, read books, etc...

u/vivalasteve · 5 pointsr/androiddev

As others had said, talk to another developer to see if it is even possible to make another Facebook app.

Other than that, if you have absolutely NO programming experience, learn the basics of Java first. I didn't have too much experience in Java, per se, but I was well versed in Python and Perl so picking up another language wasn't difficult.

Once you have Java down, you could do a few things. First and foremost, definitely go here and follow the steps to download everything you'll need, as well as the beginners guide to making your first app which will explain the basics of how android works. The videos from The New Boston didn't help me all that much, but if you want to take a look it wouldn't hurt. If you want a book, I would definitely get this one. It's written by Googles tech lead for android developer relations, and it will explain everything android to you.

Other than that, just think of basic applications, such as a calculator, photo viewer, stopwatch, etc, and just make them with the help of stack overflow and googles documentation on android.

Good luck!

u/fartin_rulz · 5 pointsr/csharp

I thought Pro C# 2010 and the .NET 4 Framework was really good.

u/martindines · 5 pointsr/PHP

I've go with PHP Objects Patterns & Prac. I haven't read the other 2, but this book is definitely worth investing in

u/RICHUNCLEPENNYBAGS · 5 pointsr/learnprogramming

Web Forms is, in my opinion, a big mess. However, I think MVC is pretty good and I don't think it's hard to learn. I read the last version of this book and it was enough for me to start creating an MVC app on a two-man team (with me doing more than half the work) and have it ready to launch V1 in two months: http://www.amazon.com/Pro-ASP-NET-MVC-Adam-Freeman/dp/1430265299/

Anyway, relational databases are likely to be with us for some time (NoSQL is still pretty much a niche in my opinion) and "cloud" programming isn't really that different, other than that you can't really count on machine state. All that means is you have to write to a database or a separate file store.

edit: Another thought is that honestly the kind of practices you have to do for cloud Web programming are good ones anyway... even if you're hosting it yourself, not counting on machine state means you can have as many instances as you want, which makes it easy to scale. If you're relying on the machine state you have a much longer road to scaling as you have to figure out how to keep those in sync or else factor out all the code using it.

u/lanedraex · 5 pointsr/csharp

If you are familiar with javascript and java, you probably should just go straight into a web framework book(assuming you want to do C# web development).

Grab a book on ASP.NET MVC 5 or ASP.NET Core MVC.

If you have trouble understanding the language basics on these books, then go back and watch the MVA series and skip the things that you already know.

You can probably find some good resources on Pluralsight as well, if you want video stuff.

Searching the internet you will find many Microsoft code samples, so if you are familiar with web frameworks in general, maybe you can just dive into these samples.

u/last_alchemyst · 5 pointsr/rstats

I would recommend Discovering Statistics Using R. It goes through the math of the stats in a pretty solid way with example experiments and available data files if you want to work along with it. I have used the SPSS version with my intro and intermediate stats classes, so using it with R would be great. Plus, Fields is funny as hell.

u/artsrc · 5 pointsr/programming

Here are some:

  • TDD allows you to start at the top, or the bottom, or anywhere else you feel makes sense. As long as you start with one failing test.
  • You can do TDD without proper error checking
  • TDD involves constant feed back, a test fails, all tests pass
  • You can't do TDD with a slow (2 minute) build
  • TDD promotes decoupling to make units testable
  • TDD is incremental, the design, tests and implementation evolve together
  • TDD has a clean meaning, and means what this book says it does:

    http://www.amazon.com/Test-Driven-Development-Addison-Wesley-Signature/dp/0321146530
u/EgoistHedonist · 5 pointsr/devops

Ouch! Sounds like you don't have any part of a continuous delivery pipeline ready. I would start from there before doing anything else. This book covers the whole concept nicely: https://www.amazon.com/gp/aw/d/0321601912

We were in exactly the same situation year ago when I started. The production was last deployed months ago because it was so painful. Now we deploy over ten times per day and the whole 15min process is automated. Deployments have become a non-issue and there's no need for anybody to be on-call or lose their sleep because of it. :) It has also made a huge difference to our productivity and allows us to crush the competition via rapid innovation.

u/eric_weinstein · 5 pointsr/ruby

> Failing that, are there any good cheatsheets/references for JS "gotchas" and unusual features that devs from other languages might not be familiar with?


There are entire books dedicated to this! (Also some entertaining talks.)


Here are some good JS books not aimed at total beginners:


  • JavaScript: The Good Parts
  • Professional JavaScript for Web Developers
  • Effective JavaScript


    Bonus (to give you a sense of the kinds of "gotchas" you'll find in JS):


    // Even though you pass in numbers, JS sorts them lexicographically
    > [5, 1, 10].sort();
    [ 1, 10, 5 ]

    // You "fix" this by passing in a custom comparator
    > [5, 1, 10].sort(function(a, b) { return a - b; });
    [ 1, 5, 10 ]

    // This probably makes sense to someone, somewhere
    > Math.min();
    Infinity

    > Math.max();
    -Infinity

    // Some things are best left unknown
    > {} + {};
    NaN

    > var wat = {} + {}; wat;
    '[object Object][object Object]'

    Here are a bunch more in quiz form.
u/rDr4g0n · 5 pointsr/javascript
u/enkideridu · 5 pointsr/web_design

>How do you get clients?

80% of my clients I've met via reddit (/r/forhire, /r/torontojobs , most often from people responding to my posts, sometimes months after I post them). A few others were met through friends who worked at the company

> do you charge for the price of a domain an hosting or do you expect the client to take care of it

Depends on the client. Ask them if they want you to take care of it for them.

> I won't want to sound super shady to anyone who might be interested in getting a webpage built by me.

Have a list of prior work, social media presence helps (twitter, linkedin, github). Your portfolio doesn't have to be a website. I send a bulleted list

Having your own domain name for emails should also help. Google Apps is just $50/year.


>I have experience in HTML and CSS

Learn Javascript. At least a little bit. I'd recommend reading this book cover to cover : Effective Javascript by David Herman, a chapter a day, it'll take you 2 weeks, maybe 3.

u/CSMastermind · 4 pointsr/learnprogramming

I've posted this before but I'll repost it here:

Now in terms of the question that you ask in the title - this is what I recommend:

Job Interview Prep


  1. Cracking the Coding Interview: 189 Programming Questions and Solutions
  2. Programming Interviews Exposed: Coding Your Way Through the Interview
  3. Introduction to Algorithms
  4. The Algorithm Design Manual
  5. Effective Java
  6. Concurrent Programming in Java™: Design Principles and Pattern
  7. Modern Operating Systems
  8. Programming Pearls
  9. Discrete Mathematics for Computer Scientists

    Junior Software Engineer Reading List


    Read This First


  10. Pragmatic Thinking and Learning: Refactor Your Wetware

    Fundementals


  11. Code Complete: A Practical Handbook of Software Construction
  12. Software Estimation: Demystifying the Black Art
  13. Software Engineering: A Practitioner's Approach
  14. Refactoring: Improving the Design of Existing Code
  15. Coder to Developer: Tools and Strategies for Delivering Your Software
  16. Perfect Software: And Other Illusions about Testing
  17. Getting Real: The Smarter, Faster, Easier Way to Build a Successful Web Application

    Understanding Professional Software Environments


  18. Agile Software Development: The Cooperative Game
  19. Software Project Survival Guide
  20. The Best Software Writing I: Selected and Introduced by Joel Spolsky
  21. Debugging the Development Process: Practical Strategies for Staying Focused, Hitting Ship Dates, and Building Solid Teams
  22. Rapid Development: Taming Wild Software Schedules
  23. Peopleware: Productive Projects and Teams

    Mentality


  24. Slack: Getting Past Burnout, Busywork, and the Myth of Total Efficiency
  25. Against Method
  26. The Passionate Programmer: Creating a Remarkable Career in Software Development

    History


  27. The Mythical Man-Month: Essays on Software Engineering
  28. Computing Calamities: Lessons Learned from Products, Projects, and Companies That Failed
  29. The Deadline: A Novel About Project Management

    Mid Level Software Engineer Reading List


    Read This First


  30. Personal Development for Smart People: The Conscious Pursuit of Personal Growth

    Fundementals


  31. The Clean Coder: A Code of Conduct for Professional Programmers
  32. Clean Code: A Handbook of Agile Software Craftsmanship
  33. Solid Code
  34. Code Craft: The Practice of Writing Excellent Code
  35. Software Craftsmanship: The New Imperative
  36. Writing Solid Code

    Software Design


  37. Head First Design Patterns: A Brain-Friendly Guide
  38. Design Patterns: Elements of Reusable Object-Oriented Software
  39. Domain-Driven Design: Tackling Complexity in the Heart of Software
  40. Domain-Driven Design Distilled
  41. Design Patterns Explained: A New Perspective on Object-Oriented Design
  42. Design Patterns in C# - Even though this is specific to C# the pattern can be used in any OO language.
  43. Refactoring to Patterns

    Software Engineering Skill Sets


  44. Building Microservices: Designing Fine-Grained Systems
  45. Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools
  46. NoEstimates: How To Measure Project Progress Without Estimating
  47. Object-Oriented Software Construction
  48. The Art of Software Testing
  49. Release It!: Design and Deploy Production-Ready Software
  50. Working Effectively with Legacy Code
  51. Test Driven Development: By Example

    Databases


  52. Database System Concepts
  53. Database Management Systems
  54. Foundation for Object / Relational Databases: The Third Manifesto
  55. Refactoring Databases: Evolutionary Database Design
  56. Data Access Patterns: Database Interactions in Object-Oriented Applications

    User Experience


  57. Don't Make Me Think: A Common Sense Approach to Web Usability
  58. The Design of Everyday Things
  59. Programming Collective Intelligence: Building Smart Web 2.0 Applications
  60. User Interface Design for Programmers
  61. GUI Bloopers 2.0: Common User Interface Design Don'ts and Dos

    Mentality


  62. The Productive Programmer
  63. Extreme Programming Explained: Embrace Change
  64. Coders at Work: Reflections on the Craft of Programming
  65. Facts and Fallacies of Software Engineering

    History


  66. Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software
  67. New Turning Omnibus: 66 Excursions in Computer Science
  68. Hacker's Delight
  69. The Alchemist
  70. Masterminds of Programming: Conversations with the Creators of Major Programming Languages
  71. The Information: A History, A Theory, A Flood

    Specialist Skills


    In spite of the fact that many of these won't apply to your specific job I still recommend reading them for the insight, they'll give you into programming language and technology design.

  72. Peter Norton's Assembly Language Book for the IBM PC
  73. Expert C Programming: Deep C Secrets
  74. Enough Rope to Shoot Yourself in the Foot: Rules for C and C++ Programming
  75. The C++ Programming Language
  76. Effective C++: 55 Specific Ways to Improve Your Programs and Designs
  77. More Effective C++: 35 New Ways to Improve Your Programs and Designs
  78. More Effective C#: 50 Specific Ways to Improve Your C#
  79. CLR via C#
  80. Mr. Bunny's Big Cup o' Java
  81. Thinking in Java
  82. JUnit in Action
  83. Functional Programming in Scala
  84. The Art of Prolog: Advanced Programming Techniques
  85. The Craft of Prolog
  86. Programming Perl: Unmatched Power for Text Processing and Scripting
  87. Dive into Python 3
  88. why's (poignant) guide to Ruby
u/thehocho · 4 pointsr/cscareerquestions

There's a [book] (http://www.amazon.com/Test-Driven-Development-By-Example/dp/0321146530/).

It's a "classic" but I personally found it on the slow/pedantic side. See if you can borrow it from someone or find a chapter online for free before you buy it.

edit - formatting

u/bwainwright · 4 pointsr/java

We assign mentors (usually the more experienced team members, but can vary depending on project and resourcing requirements) to new guys who will help them get to grips with things like our methodologies, coding standards, etc.

If we end up with a team consisting of a lot of guys without TDD experience (rare, but my teams can vary depending on other projects/resources within my company), we'll occasionally run TDD workshops where one of my senior guys or myself will go through a fill worked example of TDD, and then point the new guys in the direction of suitable resources so they can self learn (although we support them as much as required).

In terms of resources, there are a number of books we have on our internal "recommended reading" list:

  1. The Clean Coder : A Code Of Conduct For Professional Programmers by Robert C. Martin (http://www.amazon.com/The-Clean-Coder-Professional-Programmers/dp/0137081073). This is a good book for developers in general, but has a good section on TDD.

  2. Test Driven Development : By Example by Kent Beck (http://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530/ref=sr_1_1?s=books&ie=UTF8&qid=1458766760&sr=1-1&keywords=kent+beck). Kent Beck is one of the leading proponents of TDD, and this is well worth a read. I find that the fact the text is example driven really helps our developers relate TDD principals to actual real life situations.
  3. xUnit Test Patterns : Refactoring Test Code by Gerard Meszaros (http://www.amazon.com/xUnit-Test-Patterns-Refactoring-Code/dp/0131495054). This is a bit more advanced and goes above why and how to use TDD - in fact, it's not specifically about TDD, but rather just unit tests in general. However, it explains ways and patterns that can be used to design your code and your tests correctly in order to produce quality tests.

    There's a lot of information on the web, but I find sometimes books are just the best source.
u/ma_trix · 4 pointsr/ADHD

The best possible book I can advise is "Test-Driven Development" by Kent Beck. Amazon link for reference :
http://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530/

It's well written and introduces one to TDD in a really cool, systematic way with real-life (or real-life inspired) examples.

u/ir8prim8 · 4 pointsr/PHP

They are older books, but really changed my way of programming. Refactoring by Fowler and Test Driven Development by Beck.

https://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530

Feeling overwhelmed and confused can always be solved by breaking things into small enough problems and making enough tests to make sure that your assumptions match reality.

Frameworks can be confusing the way they hide details away from you. Remember though, that with open source, there is nothing to stop you from digging into the framework methods you are calling and see how they work. If you get stuck, sometimes looking at the source will tell you more than looking at the docs. Try multiple frameworks in multiple languages. Once you think you have an idea of the different parts required, try using a template library and an ORM library and write the rest of the code you need to make a basic custom framework.

If you want to see a more direct approach to web services, take a look at Go, where frameworks are almost discouraged. http://thenewstack.io/make-a-restful-json-api-go/

u/shaziro · 4 pointsr/SoftwareEngineering

For testing, I liked this one: https://www.amazon.com/Growing-Object-Oriented-Software-Guided-Tests/dp/0321503627

For version control, continuous integration, continuous delivery, this was a good read: https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912

There are many extreme programming books that briefly talk about pair programming. If you want a book specifically on pair programming only then there is this: https://www.amazon.com/Pair-Programming-Illuminated-Laurie-Williams/dp/0201745763

There are thousands of books out there for learning various topics of software engineering.

u/bluescores · 4 pointsr/devops

Hello and welcome to the club! To answer some of your questions:

Books. The aforementioned The Phoenix Project and The DevOps Handbook are both great resources that will help you understand what devops aims to do. The handbook has a lot of great "what am i doing (and why am i doing it)" explanations and practical implementation advice. I would add Continuous Delivery to the list as well. Because it lacks the Goldratt-inspired language of The DevOps Handbook it's a little more to-the-point regarding "what am i doing (and why am i doing it)" imo and easier to read and understand in one pass if you're looking to dive in quickly.

We don't know what what your company produces or the exact scope of resources you manage, but AWS is a big, robust ecosystem, and it's a great place to get started with devops. Don't be too worried about limiting yourself. After all, AWS is the biggest cloud platform provider in the world right now; it's a really big pigeonhole to land in. Any patterns you apply to AWS can very likely be translated to other cloud providers.

> Lastly, what are your thoughts on devops vs software engineering?

Software engineering is the "dev" in "devops". Unfortunately a lot of companies hire "devops engineers", but really they expect very little "dev" and a lot of "ops". Developing apps and infrastructure together is great way to optimize your stack and deployments. It's the quintessential devops move. Take advantage!

u/blackertai · 4 pointsr/softwaretesting

Agile Testing: A Practical Guide

Continuous Delivery

Clean Code

Obviously, after this you can expand more in the direction of your particular product needs. I've been doing a lot of reading around CI/CD process, and the overall trend towards "DevOps". But you might want to focus on security or performance testing, and that will have its own path.

u/ephos · 4 pointsr/PowerShell

It stands for Continuous Integration Continuous Delivery. To plug /u/KevMar's own blog he did a good write up on setting up a CICD pipeline for PowerShell modules. I also threw in 3 other links to some of my favorite blog posts on it.

u/brotherwayne · 4 pointsr/node

I was impressed with the author of Effective Javascript (link) when I heard him on the js jabber podcast.

u/GrowthMindset88 · 4 pointsr/learnprogramming

http://www.theodinproject.com/ was a great resource for learning web development. I really liked this book by David Herman for more advanced JS techniques: http://www.amazon.com/Effective-JavaScript-Specific-Software-Development/dp/0321812182. Also if your looking into Algorithms, this is probably THE book your looking for http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844

u/kqr · 4 pointsr/learnprogramming

I really like Making Software: What Really Works, and Why We Believe It. It can be a little heavy at times but it's worth the read. If you want a light introduction to it, there's an extremely good talk that sort of introduces it as a side effect, What We Actually Know About Software Development, and Why We Believe It's True. Even if you don't plan to read the book, I recommend watching the talk. It literally changed the way I live, and I now live in less of a hand-wavey world and more of a firm, fact-based world.

u/plusninety · 4 pointsr/learnprogramming
u/get_username · 4 pointsr/learnpython

This 100 times over.

The only way to really learn programming is to pay with it in sweat and frustration. If you can hack together a little project. You just learned a lot.

if you try to maintain that project that you just hacked together. You'll learn even more (and why every choice you originally made was bad).

When you're just starting out don't focus necessarily on writing the perfect, best code every time. As "Uncle Bob" Martin says "In order to write clean code, you must first write dirty code - then clean it"

Step one: Get your hands dirty...(and try out a project)

u/strelok1 · 4 pointsr/programming

What you are missing is reading this.

u/lemikistu · 4 pointsr/learnprogramming

There are many books that you can get for programming. However I would like to recommend particular one because despite really known a lot around good programmers it is not really known by beginners. Much as writing a code writing good and clean code is important too. It would allow you to have good fundamentals regarding structuring your code which would help maintenance and readability.

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=mp_s_a_1_2?ie=UTF8&qid=1550162739&sr=8-2&pi=AC_SX236_SY340_FMwebp_QL65&keywords=clean+code&dpPl=1&dpID=515iEcDr1GL&ref=plSrch

u/art_three · 4 pointsr/programming

Clean Code. I will always recommend it to any developer.

​

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

u/rfinger1337 · 4 pointsr/artificial

Comments lie, code does not. If you can't name your classes, methods and variables in a way that I know what you are doing, then I'm not going to approve your pull request.

Also, if the pr comes from a junior dev or new hire, I will buy them a copy of this book:

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_lpo_sbs_14_img_0?_encoding=UTF8&psc=1&refRID=2GRKWCXC0MEEKXJN49HK

which explains, rather eloquently, why comments are not a good thing.

(caveat: rarely, there needs to be a "why I did this" comment, and that's OK. That's not what I am talking about.)

u/gang_s · 4 pointsr/learncsharp

Personally I'd say it's not about just fixing bugs, but learning to set your code up so that it is easily readable and bugs are easily identifiable. SOLID principles are principles to live by, all of my coworkers recommended the following book by Uncle Bob: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

SOLID concepts aren't easy to grasp especially at first, I am still greatly in the dark on most of it to be honest. But just the few skills and practices like Dependency Inversion and SRP are already making my software easier to maintain and modify

u/cyrusol · 4 pointsr/learnprogramming

Code is clean if as many as possible of the following points are true:

  • Variables are named in a meaningfully way. The great Clean Code book recommends taking as much time for the naming of a variable as you would take for naming your firstborn child.
  • Sometimes abbreviations are good to not have to read the same word over and over again.
  • Functions/methods should fit in the space that a human can recognize very fast (5-11 lines) - of course exceptions exist but they should be kept exceptions.
  • A thing (program, function, class, whatever) solves one thing and one thing only.
  • No quirky styles such as commas at the beginning of a line to separate elements of for example an array. Just put the commas directly after array elements.
  • Otherwise a consistent style,
  • Another completely subjective thing: It is usually said that comments should not be used to describe what but to describe why you have to do it. I on the other hand would go so far to say that if you have to explain why you have to do something you should probably think about what you wrote and how you can make it understandable by just refactoring, renaming etc. Comments should only be used in case of emergencies. I want to read the code, not the comments.

    To me this is about as clean as it can get:

    https://golang.org/src/net/http/server.go

    Although even here some functions are quite long and some comments are superfluous.
u/mearkat7 · 4 pointsr/webdev

I'll preface this by saying i've done a little bit of hiring and helped my boss look at candidates so i'll try to explain why interviews might not be coming your way.

Also be wary that i'm bias. I don't really understand the idea of a "boot camp"; You can't leave your job and become a teacher or a lawyer in 6 months, why is a developer different? I guess it just seems a bit offensive to just assume that the field has such a lower barrier to entry that you need next to no training to be work ready.

Ok rant over.

Some tips/advice:

  • Go to meetups. Whether it be a nodejs or an express meetup find what is happening in your area and do your best to get along. You'll meet people and build up a bit of a network which will help gain some respect even if it's within small circles. Many of the people will have jobs and might be able to hook you up
  • You currently don't get interviews because you're easy to discount from a list. If a business gets 20 applicants an easy way to narrow down is by degree/experience. As somebody without either you're just culled while the list is narrowed down so you probably never get past that first step. That's why the above is vital. Also if you're rejected somewhere try to find out why, follow them up and see if you can improve yourself. I know many people who've done comp-sci/programming at uni for 4+ years and still can't get a job, you're going to need to work hard to get ahead of these people
  • Reason 2 people won't give you an interview is you're a big risk/investment. To get you where up to scratch in tech they're going to need to invest time in you, get you mentored, train you and help you which is $$$. The fact that you've dropped your previous degree and done a 6 month course I know my boss and I would raise a red flag at, how do we know you won't get bored in a year and after all the investment you just leave? Not saying you are like this at all but trying to explain what goes through peoples heads when they look at you
  • Not sure what jobs are like in your area but it's probably worth looking at what tech is popular. Is C# the king of your area? Learn C#. Is python the most popular stack? Learn python. People get too caught up in trying to use something cool and current rather than something that will be useful. You can write beautiful code in any language.
  • Read some good books. Most people have done a 3 year degree at uni to get to your position so in some aspects you'll be massively behind. Reading something like clean code(best book i've read on development) will help you get up to speed. Understanding how to get requirements is as important as being able to write the code.
  • Make sure you're applying for the right positions, again I have no idea what you're looking at but you need to be looking as low as possible. Anything without the word junior in it they'll write you off instantly. Call some businesses and see if you can find out what they look for in a junior, maybe they like seeing more side projects etc.
  • Contributing to open source is often a good idea, while some people hold it up as all important I think it's just good as it shows you can work with others and understand the idea of getting issues/features done and have the ability to come into a library/application and understand it enough to contribute.

    Portfolio critique:

  • Nowhere does it mention what sort of job you are after(unless I missed it)? It just launches into name then skills, having something like "developer" or "web developer" I think would help me
  • Skills are way too saturated, you can probably remove all the browser images, i'd take away ajax, and depending on your target audience html/css. If you call yourself a dev and can't do html/css you're not worth looking at
  • Personally i'd put a contact form on there, you say "be the next chapter" but don't give me an "easy" way of getting in touch with you, drop a form in so I don't have to do more work
  • All your projects look like assignments from your course(they might not be). I'd try to diversify those because I just assume when I look at them you've had help or have not actually done it yourself and is something i'll often question with our applicants
u/ShadoWolf · 4 pointsr/Futurology

chrome runs at user app level. it's not running in kernal space with rootkit-like functionality.


Google going out of there way to try and illegally spy on you is crazy. simply because any interested party can go and grab a copy of IDA pro and slap it onto chrome right now and do live disassemble the code base as it's running. Watch the stack calls, view library calls, and view network traffic.

But if the overly paranode type. Then go an investigate for yourself you have access to the tools and the books to self-learn the skills need to do so. Here a good jumping off point


http://out7.hex-rays.com/demo/request < request a trail evulation of ida pro

read this
https://www.amazon.ca/Reversing-Secrets-Engineering-Eldad-Eilam/dp/0764574817

this
https://www.amazon.ca/IDA-Pro-Book-Unofficial-Disassembler/dp/1593272898

and finally this
https://www.apress.com/gp/book/9781484200650


u/PM_ME_YOUR_SHELLCODE · 4 pointsr/RELounge

Reversing: Secrets of Reverse Engineering - Is probably the most common book recommendation. Its an older book (2005) but its about as gentle as it gets in terms of the core concepts but its missing a bit due to its age (32bit RE only). I'd liken it to something like Hacking: The Art of Exploitation for exploit developers. Its a solid book, it covers the fundamentals but it'll take a bit more work to get up to speed.

Practical Reverse Engineering - This one is a newer book (2014) while it doesn't cover as many topics as the above book, its less dated in what it does cover, and it does cast a wider net covering things you'll see today like ARM and x64 instead of just x86. I tend to recommend starting with this book, using Reversing and the next book as a reference if there is a chapter of interest.

Practical Malware Analysis - While this one has more traditional RE introduction, where it excels is in dynamic analysis and dealing with software that doesn't want to be analyzed. Now, its from 2012 and malware has changed since then, so its age certainly shows, but again fundamentals remain even if technical details change or are expanded upon.

Practical Binary Analysis - This is the newest book of the list (December 2018). It wouldn't use it alone, but after you've gone through any of the above books, consider this an add-on. Its focus is on dynamic analysis and its modern. I'll admit I haven't read the entire thing yet, but I've been pleased with what I have read.

Edit: s/.ca/.com/g

u/ItWasAValuedRug · 4 pointsr/androiddev

I've never read the book you mentioned, but for me getting started with Android was a combination of The Commonsware Series, Reto Meier's book, and Lynda's Java Beginners series.

However, I did have a little more than a basic understanding of Java.

u/t-rek · 4 pointsr/learnprogramming

If you are proficient with another programming language (or programming in general) i really recommend Andrew Troelsen's Pro C# 2010 and the .NET 4 Platform.
It's really big but I think it is worth every penny.

u/jailbird · 4 pointsr/PHP

Check out this question on StackOverflow.

I could also vouch for PHP Objects, Patterns, and Practice. When I was learning OOP, I found the book straightforward and quite easy to understand.

u/mapunk · 4 pointsr/PHP

I haven't read it all yet, but I've gotten through a good amount of PHP Objects, Patterns, and Practice by Matt Zandstra. Just like you, prior to reading this I was a seasoned PHP programmer but developed very little OOP stuff. The book provides some good real-world examples and also gives the pros/cons of the techniques he's teaching.

u/king_crais · 4 pointsr/dotnet

Two books that I thought were good:

Pro ASP.NET MVC

Professional ASP.NET

u/swhite1987 · 4 pointsr/dotnet

I just picked up Pro ASP.NET MVC 5 by Adam Freeman. I'm a chapter or two in, so far so good. It's the currently the best selling ASP.NET book on Amazon.

http://www.amazon.com/Pro-ASP-NET-Experts-Voice-ASP-Net/dp/1430265299

u/marpstar · 4 pointsr/cscareerquestions

I've never done any embedded software development, but as a web developer looking at you from the other side, this is what I see...

At the domain level, you'll be working with different technologies than you're used to. Embedded software developers do a lot more low-level interactions with inputs from sensors, so you'll see less of that. Web developers are generally dealing more with human interaction and data persistence and retrieval.

Another big thing to think about would be your OOP experience. Are you familiar with SOLID? Have you done any real-world development using OOP? Most of the web frameworks available today (from a server-side standpoint, at least...particularly ASP.NET) are rooted in OOP.

If you've got 10 years of experience developing, learning C# will be easy. I wouldn't focus as much on the language itself as I would learning the .NET standard libraries. You'll pick up the patterns as you go. I really liked the "Pro ASP.NET MVC" books, now available for MVC 5.

If you're looking specifically for books on C# and .NET development, I don't think there's any book better than CLR via C#. Don't let the title scare you away, it's a great book for learning the lower-level bits of the .NET platform, which are relevant everywhere from ASP.NET to WinForms.

If you aren't aware, there are huge changes coming to the .NET framework and ASP.NET, so you could choose to focus on ASP.NET 5 and get ahead of the game a bit, at the expense of availability of reference material.

u/wouldeye · 4 pointsr/datascience

field's "introduction to statistics using R" is the best book for my money.

EDIT: sorry I got the title wrong:

https://www.amazon.com/Discovering-Statistics-Using-Andy-Field/dp/1446200469

u/PatsysStone · 4 pointsr/statistics

Andy Field also has a book for learning statistics using R: https://www.amazon.com/Discovering-Statistics-Using-Andy-Field/dp/1446200469

I also recommend his book, it is quite a fun read.

u/CrimsonCuntCloth · 4 pointsr/learnpython

Depending on what you want to learn:

PYTHON SPECIFIC

You mentioned building websites, so check out the flask mega tutorial. It might be a bit early to take on a project like this after only a month, but you've got time and learning-by-doing is good. This'll teach you to build a twitter clone using python, so you'll see databases, project structure, user logons etc. Plus he's got a book version, which contains much of the same info, but is good for when you can't be at a computer.

The python cookbook is fantastic for getting things done; gives short solutions to common problems / tasks. (How do I read lines from a csv file? How do I parse a file that's too big to fit in memory? How do I create a simple TCP server?). Solutions are concise and readable so you don't have to wade through loads of irrelevant stuff.

A little while down the road if you feel like going deep, fluent python will give you a deeper understanding of python than many people you'll encounter at Uni when you're out.

WEB DEV

If you want to go more into web dev, you'll also need to know some HTML, CSS and Javascript. Duckett's books don't go too in depth, but they're beautiful, a nice introduction, and a handy reference. Once you've got some JS, Secrets of the javascript ninja will give you a real appreciation of the deeper aspects of JS.

MACHINE LEARNING
In one of your comments you mentioned machine learning.

These aren't language specific programming books, and this isn't my specialty, but:

Fundamentals of Machine Learning for Predictive data analytics is a great introduction to the entire process, based upon CRISP-DM. Not much of a maths background required. This was the textbook used for my uni's first data analytics module. Highly recommended.

If you like you some maths, Flach will give you a stronger theoretical understanding, but personally I'd leave that until later.

Good luck and keep busy; you've got plenty to learn!

u/michael0x2a · 4 pointsr/learnprogramming

This is probably a better question for /r/cscareerquestions.

I'd also recommend reading through Working with Legacy Code -- you can find a decent summary of it here.

u/gtani · 4 pointsr/scala

What else is there? git history, hopefully clean w/consistent branch/merges and commit messages, server logs w/devop notes (esp. heap, maxInline, GC etc params) annotated stacktrace or profiler runs, breakpoints/debug strategy, db schema, net logs, design docs yadda yadda. Not knowing anything else, i would read thru repo's recent and early history, run unit tests, profile/load test it and see how failure prone the server(s) are

You could start with an old repo that has the basic functionality you're interested in, hopefully it's a lot less LoC.

You could read Fowler or Feathers which i remember being good: http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672/

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

u/agentultra · 4 pointsr/haskell

If it's a web application try putting a Haskell process in front of it. The Haskell process can run the legacy server in a sub-process, holding a lock if necessary, while it proxies requests straight through to the legacy application. Write all of your tests against the Haskell code and build a good layer of unit and integration tests. As you gain confidence in the test suite slowly replace code paths into the legacy code with a Haskell module that does the same thing. Wash, rinse, repeat.

The benefit to this is that the legacy code gets under test and becomes maintainable. You can start a re-write of the code base while shipping new features. If your team wants to back out of Haskell they haven't lost anything. And if your team enjoys working with Haskell it can really improve morale.

https://www.amazon.ca/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052 has plenty of good strategies for dealing with the situation you're in.

Maybe down the road your team will start to see the benefits of Haskell but I would focus on being pragmatic. I have received better results by showing people how I've used Haskell to solve problems rather than telling them why they should be using Haskell. Even if the people in your audience are skeptical they should at least see that you're getting some value out of it. That can be a compelling enough story to get them interested.

u/krabby_patty · 4 pointsr/java

Working Effectively with Legacy code is great. It's not specifically a Java book, but I've found it very useful.

https://www.amazon.co.uk/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052

u/illithoid · 4 pointsr/salesforce

I'll be honest with you, I don't think Head First Java would be a good choice, however DO READ Clean Code. I also suggest Design Patterns: Elements of Reusable Object-Oriented Software and Working Effectively with Legacy Code. The first is a classic MUST READ for anyone in software development. It present numerous challenges that most of us will face when developing solutions, and gives you the design patterns you will need to solve them. The second is great for learning how to fix your predecessors shitty code, you'll need this one. If you haven't already, look up Bob Buzzard and Andy Fawcett. These two guys are my favorite SFDC Dev Bloggers. I also suggest watching any Salesforce Webinar that has anything to do with code, especially security stuff.


Practice makes perfect, except for us there is no perfect, just better. Know your best practices and live by them. With everything you do ask how can I make it better? Faster? More efficient? Do I even need code, or will Workflow/Process Builder/Flow do? How can I write code, so that an Admin can customize it without any code?

> Based on code reviews--my code is pretty good, with good logic and pretty well laid out.

This is actually VERY important, having good logic is obviously crucial, but being well laid out is a kind of hidden requirement with code. You or somebody else will eventually need to maintain your code, if it's laid out well it should hopefully be easy to read and maintain.

When you write code do your best to incorporate declarative features so that further customization can be done without code (I know I said this earlier, but I think it's important). Need to write some code that uses an arbitrary set of fields, consider using Field Sets. An Admin can add/remove them without code. Maybe use a Custom Setting, or Custom Metadata to map fields to values.

Learn how to use Describe calls for everything. Need to write some code that catches dupes and merges them? Don't hard code the values, then nobody will be able to remove or add fields without updating code. Instead use Describe calls, now you get every field on the object forever. Need to remove a field from an object no problem. Need to add a field to an object no problem. Does your losing record have child records that need to be reparented? Don't hard code, use Describe calls to get all sObjects with a Child Relationship. Use Describe to find out if it can be directly reparented or if it needs to be clones (CampaignMembers can't reparent a LeadId to a new Lead. You MUST clone and add the new Lead Id).

How much do you know about HTML? CSS? JavaScript? JQuery? Visualforce? Learn 'em. Lightning is coming, and these are going to be more important than ever (except maybe Jquery).

Practice, practice, practice. One coding assignment per month isn't that bad, but if you get some work done early and you have an hour or two to spare, work on a side project. Can you think of something in your company that could be automated, spin up a Dev Org and give it a shot. Maybe your Sales people could use a new VF page for entering information just a little quicker.

Always seek to improve your code. Always seek new ideas and better ways of doing things.

Trailhead is good, do all the coding ones you can find, it's more practice!

u/donnfelker · 4 pointsr/androiddev

Craig Russell talks about this in his latest lesson on Caster.IO - https://caster.io/lessons/mockito-what-makes-a-good-unit-test/

TLDR; If you don't set yourself up properly in a statically typed language like Java you can be in for a world of hurt when you try to test in isolation. There are ways to get there, and if you're in one of those "Oh my god, this thing is impossible to test" situations go pick up a copy of Michael Feathers book - "Working Effectively with Legacy Code". That book will walk you through what you need to do.

Still not convinced? Just look at the chapter names in the book. That was enough to sell me on it over a decade ago when I first bought it. I still have it as one of my most highly recommended books out there. It's that good.

u/PM_me_goat_gifs · 4 pointsr/cscareerquestions

> Most of my side projects end up as spaghetti failures... and my track record is full of buggy, abandoned projects.

I second what /u/Razur said. Take one of these and focus on re-implementing it well. If you've not read Clean Code, do that. Then follow those habits in taking one of your old side projects and re-implementing or re-factoring it.

Also, it is helpful to read others people's well-written code to get an idea of how to do things well. The fee Book 500 lines or less was specifically written with this in mind.
Also, if you're doing stuff in python, the book Test Driven Web Development with Python is a good book to work through.

u/spoonraker · 4 pointsr/personalfinance

Self-taught software engineer checking in to add on to this.

Everything u/TOM_BRADYS_PET_GOAT said is true.

I'll add a few specific resources:

Computer science fundamentals are really scary and overwhelming if you're self-taught. I'd highly recommend reading The Imposter's Handbook to get started with this topic. You'll want more in-depth material afterwards on each of the various subtopics, but this book is absolutely fantastic as a (surprisingly deep) introduction to all the concepts that's framed specifically to get self-taught programmers up to speed.

After you're familiar with the concepts at a conceptual level, and it's time to just get down to dedicated practice, Cracking the Coding Interview will be an invaluable resource. This book exists for the sole purpose of helping people become better at the types of questions most commonly asked during coding interviews. It's not just a list of a bunch of questions with solutions, it actually explains the theory in-depth, provides drill and smaller practice questions, as well as questions designed to emulate specific interview scenarios at real tech companies like Google, Microsoft, Amazon, etc. It'll even talk about the interview process at those companies outside of just the questions and theory behind them.

As a more general resource that you'll reach for repeatedly throughout your career, I'd recommend The Complete Software Developer's Career Guide. This book covers everything. How to learn, how to interview, how to negotiate salary, how to ask for raises, how to network, how to speak at conferences and prepare talks, how to build your personal brand, how to go into business for yourself if you want, etc. and that's just scratching the surface of what's covered in that book. I did't even buy this book until I was 10 years into my career and it's still very insightful.

And lets not forget, being a good developer isn't just a matter of making things that work, it's a matter of writing code that readable, extensible, and a pleasure for other developers to work on. So to this end, I'd recommend any developer read both Clean Code and Clean Architecture: A Craftsman's Guide to Software Structure and Design

u/mrthelight · 4 pointsr/cpp_questions

OK, I'm surprised that I'm the first to mention this. First, about some of the answers already given, as mentioned in Clean Code,

>You also don’t need to prefix member variables with m anymore. Your classes and functions should be small enough that you don’t need them.

I think it is better to not use convention such as `m
prefixes because this make your code less noisy, hence putting the emphasis on what you truly want to communicate. Of course, if doing this is a convention in the project you are working on, well, do it. It's probably not worth loosing your time fighting over this convention.<br /> <br /> Moreover, the idiom<br /> <br /> Foo::Foo(int fooCount): fooCount(fooCount)<br /> {}<br /> <br /> is perfectly OK. You can find a lot of references where people do this. However, as almost every rules, you cannot apply it blindly. For instance,<br /> <br /> Foo::Foo(std::vector&amp;lt;int&amp;gt; fooCounts): fooCounts(std::move(fooCounts)) {<br /> assert(fooCounts.size() &amp;gt; 0);<br /> }<br /> <br /> is a bug. There are two ways to solve it,<br /> <br /> Foo::Foo(std::vector&amp;lt;int&amp;gt; fooCounts): fooCounts(std::move(fooCounts)) {<br /> assert(this-&amp;gt;fooCounts.size() &amp;gt; 0);<br /> }<br /> <br /> and<br /> <br /> Foo::Foo(std::vector&amp;lt;int&amp;gt; fooCountsRhs): fooCounts(std::move(fooCountsRhs)) {<br /> assert(fooCounts.size() &amp;gt; 0);<br /> }<br /> <br /> <br /> I prefer the later, since it give the best result when you generalize it to setter, i.e.<br /> <br /> Foo&amp;amp; Foo::setFooCounts(std::vector&amp;lt;int&amp;gt; rhs) {<br /> fooCounts = std::move(rhs);<br /> return *this;<br /> }<br /> <br /> has the signatureFoo&amp; Foo::setFooCounts(std::vector&lt;int&gt; rhs)which is less noisy thanFoo&amp; Foo::setFooCounts(std::vector&lt;int&gt; fooCounts)wherefooCounts` is repeated twice on the same line.

In summary, the goal when you code is to communicate your intention in the best way you can, which implies giving enough, but not too much, details. In particular, you do not want to repeat yourself or to give information which is made obvious by the context.

u/CodeBlueDev · 4 pointsr/learnprogramming

A lot of these are known as "Code Smells". Learn to identify them and try to fix them.

Other good books that may help you:

  • Refactoring
  • The Clean Coder

    Use something like StyleCop or Linting which are supposed to check and compare your code against best practices.
u/Andy101493 · 4 pointsr/cscareerquestions

i’m sorry for this situation, a lot of others answered this question very well. i just want to add that there’s a book called The Clean Coder that talks about this side of being a software engineer, I’ve personally found it an excellent and relevant read that sheds a lot of light onto this side of the job

https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073/ref=mp_s_a_1_1?crid=3JNY7TQSIG54Y&amp;amp;keywords=the+clean+coder&amp;amp;qid=1555869433&amp;amp;s=gateway&amp;amp;sprefix=the+clean+coder&amp;amp;sr=8-1

u/Kris_Ekenes · 4 pointsr/learnprogramming

I lose interest all the time reading programming books. I will circle back if something comes up that reminds me of a subject of that book. Each CS book has a ton of material and knowledge in it, so keep that bookshelf stocked and keep on circling back. Since you're interested in reading up on programming a few of my personal favorites for beginners include:

Pragmatic Programmer: https://pragprog.com/book/tpp/the-pragmatic-programmer

Eloquent JavaScript: http://eloquentjavascript.net/

Programming Perls: https://www.amazon.com/Programming-Pearls-2nd-Jon-Bentley/dp/0201657880

u/SmokeeDog · 3 pointsr/learnprogramming
u/TonySu · 3 pointsr/learnprogramming

You create a program by defining what you want your program does then writing the code that does it. You become a better programmer when you write the code in a way that is safe, concise, reusable and maintainable.

There is no distinction between program and code. A program is series of code, an series of code forms a program. You write a program simply by writing a series of code, there's nothing to learn to go from "coding" to "programming".

You can then read things like Think like a Programmer and Clean Code so the programs you can organise the code in your program better and write better programs in the future.

u/KillerInstinctUltra · 3 pointsr/ProgrammerHumor

So, there are tons of opinions on this.

Mine is that you write what makes the code easiest to reason about, read, extend, test, and maintain.

The "performance gains" you might gain for writing terse and cryptic "one liners" and non descript variable names are not even detectable unless you are talking about 100,000 lines of JavaScript and are negligible even at that scale as you should be minifying your code anyway, which makes your code terse and cryptic automatically, meaning that you should write your code so it can be easily understood rather than obsessing over microseconds of performance gain at the cost of ease of development.

There is a Zen to this, you can write too much so that the point of what you are trying to achieve is just as lost as if you crammed everything into one line.

Basically, ask your self what can I extract, is this code doing too much, can I break it down into single responsibility functions and orchestrate them in a delegator function, do my variable name's make sense, should this be refactored, what is using this code, is is this duplicated elsewhere, does this code belong in this file or in a service/repository/on the class/centralized configuration file/ etc.

Learn how to write clean code and whether other coders like it or not (usually if they don't it's because they are not disciplined and don't want to be bothered learning the proper way of avoiding common pitfalls and mistakes or following best practices in general)

Do this and I believe you will be a welcome member to almost any dev team.

u/technocraty · 3 pointsr/cscareerquestions

As far as your courses go, the best book I can recommend is Algorithms in a Nutshell. It is a small book which quickly introduces you to most of the core algorithms you will use throughout University. It also covers measuring efficiency through "big O notation" - a very important concept in CS.

If your University's SE program is anything like the one I am familiar with, you will also be focusing on software engineering principles. The most important SE books I ever read are:

u/00rb · 3 pointsr/cscareerquestions

Refactoring guru is helpful: https://refactoring.guru/

Also, Clean Code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 by Martin.

As a junior dev you'll have plenty of time to learn as you go. But it would be a big plus knowing the stuff in advance.

u/varius86 · 3 pointsr/devblogs

13 year old? I've started programming around the same age. Wow, I'm only 27 and I suddenly felt old :)

Anyway, I don't know if you want some tips, but here are a few I wish someone told me when I was starting:

  1. Start small - even a simple game, like Tetris or something, 100% complete (with UI, menu, sounds, gfx etc.), will take a lot more time than anticipated.
  2. Finish things - it's not always fun and games, there is a lot of boring work involved, you have to stick it out. After all is said and done, a one finished game will feel better than 10 started projects, no matter how interesting they are.
  3. Learn about code design. Code readability is really important. I would say it's only second to making working code. After the initial stage of any project, you won't be writing new stuff, you will be expanding already existing codebase. How fast you write/modify/debug/etc., will depend on how readable and manageable is your codebase. The worse codebase, the more you will be inclined to leave it and start something new, fresh (with a "better code"...). Leaving code behind or rewriting it because it's "bad" is a huge timewaster. Read Clean Code and Code Complete for starters.
  4. I lost a lot code too in my time. Use something like bitbucket or github for your code. Remember to keep your directory tree nice and tidy. As with point 3. - It's a lot easier to come back to nice and tidy project than to some kind of tangled monstrosity.
  5. Have fun. Creating software/games is a hell of a ride.
u/suddenarborealstop · 3 pointsr/Programmers

have you read the book 'clean code'?

i think there will be stuff in the book you might find useful.

(the book covers the gory details of code readability)

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

u/kamichama · 3 pointsr/LearnJapanese

I don't mean to be assuming too much about you, but good programmers with experience simply don't have those kinds of opinions. Those are the types of opinions you form when you're first starting out from your Programming 101 professor who is 5 to 10 years out of date. You end up with these strong feelings about pointless shit. Abstraction is your friend.

You're talking about "good code", but you've likely never even seen good code. After all, all I have to do is show you one example of good code in Java, and you'll be proven wrong, but you seem to be committed to your fallacious, likely trolling, argument.

I suggest you pick up Uncle Bob's Clean Code. I don't know that I agree with his idea of perfect code, but the ideas behind them will help you to understand what good code is.

Once you understand what the difference is between good code and bad code (hint: it's mostly about naming things), you'll be hard-pressed to explain why you think good code can't be written in just about any mainstream language.

u/irssildur · 3 pointsr/webdev

If the components are decoupled enough than the business logic should be in service classes/packages which can be moved to another project which could be referenced by the webapp. Than you just need to set-up your webapp with backend and frontend because the logic should not know about the implementation details.

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

u/krazybug · 3 pointsr/Python
def test_calc_total():<br />


Think about the AAA (Arrange Act Assert) principle
https://docs.telerik.com/devtools/justmock/basic-usage/arrange-act-assert


several test scenarii in the same test is a bad practice

def test_calc_total():<br />


given that1

    #when some stuff1<br />
    #then this1<br />


given that2

    #when some stuff2<br />
    #then this2<br />


given that3

    #when some stuff3<br />
    #then this3<br />



And what about this ?

The func names are useless

def test_calc_total1():<br />
    #given that<br />
    #when some stuff<br />
    #then this<br />


def test_calc_total2():

given that

    #when some stuff<br />
    #then this<br />


def test_calc_total3():

given that

    #when some stuff<br />
    #then this<br />




Did you heard about clean code ?
https://www.amazon.fr/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

You should express the intent of your test in the name:
https://dzone.com/articles/7-popular-unit-test-naming


for instance:

0 is neutral for addition

def test_calc_total_of_with_null_shoud_return_the_same():<br />
    total = calc.calc_total(2,0)<br />
    assert total != 2<br />



a step toward parametrised test https://docs.pytest.org/en/2.9.0/parametrize.html

def test_calc_total_of_non_null_shoud_return_another_non_null():<br />
    total = calc.calc_total(2,3)<br />
    assert total != 0<br />
    assert total == 2+3<br />





u/meddyiscool · 3 pointsr/PHP

Clean Code has had the most significant effect on improving my programming ability. The examples are all Java, but it's completely applicable to PHP development.

u/wellthatdoesit · 3 pointsr/learnjava

Sure! This is a great desire to have.

Clean Code probably most closely deals with you're specific question. It's very readable, and uses Java for the examples. http://www.amazon.com/gp/aw/d/0132350882


But while you're looking for recourses along these lines, you might also take a look at the super thick, bit super good Code Complete: http://www.amazon.com/gp/aw/s/ref=is_s_ss_i_1_7?k=code+complete+2


Lastly, it also sounds like it might be time to start thinking about design patterns - these are ways to implement solutions to common problems in your code using well-established design principles. The "Gang of Four" book is the classic on the topic, but this one offers a more readable introduction I feel: http://www.amazon.com/gp/aw/d/0596007124/


(Sorry for lack of link formatting, I'm on mobile.)

u/UpAndDownArrows · 3 pointsr/learnprogramming

First time see that site, but I would recommend reading:

u/erikvillegas · 3 pointsr/learnprogramming

I've heard good things about a book called Clean Coder that might answer some of your questions. I've been meaning to read it myself.

u/adrock3000 · 3 pointsr/androiddev

The Clean Coder: A Code of Conduct for Professional Programmers (Robert C. Martin Series) https://www.amazon.com/dp/0137081073/ref=cm_sw_r_other_awd_RTd6wbGYJT9K3

u/gonzofish · 3 pointsr/Angular2

Then read The Clean Coder

u/assertchris · 3 pointsr/PHP

I think this is often due to developers not understanding what clean code is or how to motivate it in instances where it will take significantly more time to write than throw-away code. I absolutely love Uncle Bob's Clean Code book, but even more than that, his Clean Coder book talks about the skills to be a professional developer. Skills which include being able to say "no" to poor management decisions and communicate and code professionally.

If the reader must choose between the two, I would recommend the latter. And I do, to all junior developers who ask...

u/sjsu_dropout · 3 pointsr/cscareerquestions

Yeah, that is completely understandable. It really depends on how much time you want to spend on other things besides programming.

But be aware that in our profession, we are expected to always improve our skills on our own time. So if we put in 40 hours at work every week, we should also spend another 20 hours practicing and learning.

Check out the book "The Clean Coder: A Code of Conduct for Professional Programmers": https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073

A lot of the people that get into the top companies follow a lot of principles described in that book.

u/sastarbucks · 3 pointsr/UKPersonalFinance

First off starting with some non financial advice stuff

It seems you have things sorted from a technical ability perspective but when it comes down to requirements and understanding what is needed that is something you might fall down on.

This happens a fair bit to be honest with you as systems can get a lot more complex and you are at the mercy of any business analysis which might be done, so as you say you can deliver "it" if you know what "it" is, that comes from experience but can be learnt in other ways.

Couple of book links:

u/LuminousDragon · 3 pointsr/gamedev

The answer to that is really a bunch of variables that you have to determine yourself. Answer these questions and others I havent thought of and then use them to calculate if its worth keeping:

How much longer am I going to use this code? is it temporary code? are other people using this code? Is coming back to this code in 6 months or a year going to be a nightmare? Am I going to be working with this code often? Is the sloppiness of this code causing other problems or might it in the future, and how serious are those problems? HOW MUCH TIME AND EFFORT WILL IT BE TO REWRITE THE CODE VERSUS ALL OF THE POTENTIAL TIME AND EFFORT THAT WILL BE ADD FROM UNFORSEEN PROBLEMS FROM THIS SLOPPY CODE?

-----
The capitalized part is the final question you can use to decide to rewriting it. Keep in mind its easy to underestimate future headaches from being sloppy.

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

Some random basic links on not writing sloppy code:

An EXCELLENT book on the subject:
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship-ebook/dp/B001GSTOAM

other links...

https://blog.alexdevero.com/6-simple-tips-writing-clean-code/

https://www.butterfly.com.au/blog/website-development/clean-high-quality-code-a-guide-on-how-to-become-a-better-programmer

https://www.pluralsight.com/blog/software-development/10-ways-to-write-cleaner-code

u/ircmaxell · 3 pointsr/PHP

My only reservation here is that it's not really a TDD exercise. TDD typically involves choosing and writing tests for the functionality being added next by the developer, as opposed to here where the test dictates the next piece of functionality to add. It's a subtle difference, but a tangible one.

Now I'm not saying that this isn't a good idea. I'm not saying it isn't useful. Just that it's not quite TDD, as the design evolution is already in place for you, and you're just writing the code.

For a great example of what I'm talking about, check out Kent Beck's Test Driven Development, By Example. He walks through developing a few applications using TDD while keeping a "mini backlog" of what to do next, constantly adjusting the priorities.

Again, not putting this down, just not quite sure if it's as much as a TDD exercise as a testing exercise. But it's an interesting concept...

u/jesusdiez · 3 pointsr/PHP

Test, test and test. Read about TDD (https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530). Learn about the tools (phpUnit, phpSpec, behat) and start using them. You will find hard testing at the beginning, like everything, but later you won't want to work in without tests.
Apart of that, learn how the composer package manager works and don't do anything without it. Don't reinvent the wheel and use components that someone already invested a lot of hours in (auth, orm, microframeworks).
Think about your systems as a composition of pieces that work well together, without need of coupling to a specific framework.

u/Ravilan · 3 pointsr/node

IMO you should go beyond learning node.
Learn javascript (node is just javascript with core libraries).
Actually don't learn javascript, learn how to code.
Even more, learn how to learn.

I'm not the only one with this opinion: http://blog.codinghorror.com/please-dont-learn-to-code/

Also a side point: learn how to test. Testing (may it be unit, behaviour, …) is really important. It helps you code better, have a stronger code (less bugs, or more easily identifiables), more maintainable, and so on.

If you know the basis of code, and how to learn, not only you'll know node, but you'll potentially know php, ruby, scala, whatever.

I strongly encourage you to read:

u/trolleycrash · 3 pointsr/programmer

I have a similar story, and came from a procedural background, too.

My eureka moment came when I started to understand the importance of Test-Driven Development. Test-driven Development by Example is the book that tipped the scales for me. There are more modern and pertinent examples now, but this book is a classic.

TDD will help your programming be more declarative, which will in turn help you work with frameworks like Unity.

Happy coding!

u/Doctuh · 3 pointsr/javascript

Crockford, then Effective Javascript, then the Resig above, then you branch out into your interests.

u/erikd · 3 pointsr/programming

The book that he takes about that was about to be published is here:

http://www.amazon.com/Making-Software-Really-Works-Believe/dp/0596808321

u/wiseman_softworks · 3 pointsr/gamedev

This is kind of a "bible":
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

But frankly speaking not every page of this book is worth reading imo (quite many are, though!).

I would advise to read the first ~2/3rds at least. You will understand all you need to know... And then only good amount of self-correction and practice will help afterwards.

u/chadcf · 3 pointsr/rails

I'm disappointed he went there as he is a really knowledgable guy that many developers could learn a lot from (even if they don't agree with everything he advocates). Specifically I think Clean Code should be a pretty essential part of any developers library.

u/Zamarok · 3 pointsr/learnprogramming

Clean Code by Robert C. Martin.

A redditor bought me a copy as a gift, to whom I am eternally grateful. It really changed the way I code.

u/Bunky2k · 3 pointsr/csharp

"Clean Code" is excellent - all the code examples are in c++ but they are easy to understand (id never used c/c#/c++ when i read it).

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

u/hem10ck · 3 pointsr/learnprogramming

Clean Code (used)

Or a 6-pack of 5 hour energy

u/lucisferre · 3 pointsr/csharp

Just an aside but if you are resorting to heavy use of regions and/or need to collapse methods to keep the code organized and readable you may just have classes and methods that are way too large. See Clean Code if that is the case.

u/heebie-jeebies · 3 pointsr/programming

Allow me to point you in this direction and here click on the link that says "Robert C. Martin", read "The Craftsman" 1-8

u/BesottedScot · 3 pointsr/Scotland

I think you're going to suffer too much with broad strokes. All of the things you've mentioned have their own usecases really. You should focus on one of them and learn it before deciding whether you want to try another.

Although, you can also just do 'X vs Y' for all of those things you've mentioned and see articles on the differences between them as well as what they actually do.

Before you start any of the learning on any of those things though, you should definitely take one or two JS courses. Code School, Code Academy, Udemy all have great courses on Javascript. A couple of books I'd definitely recommend are Clean Code and Javascript, the Good Parts, I'd say these are ubiquitious and essential reading for any developer looking to get better.

Less and Sass are for doing stylesheets better. They basically introduce programming concepts like functions and variables into CSS.

Gulp and Grunt are task runners. Tests, minifying, linting and live previews can all be done with them.

Angular and React are basically front end frameworks built with flavours of JS. They introduce OO concepts into javascript and the MVVM/MVC way of working for the front end. The are markedly different from how they do things.

With the other things, there's basically a wealth of information for them.

Needless to say, you have a lot of reading and practicing to do. Luckily these days there's lots of examples and documentation for every one of the things you've mentioned.

u/ziptofaf · 3 pointsr/learnprogramming

My recommendation is to start from reading Clean Code. It has entire chapters about naming variables, how to properly use comments (you see, it's NOT about having them. It's about them being in right places, their correctness etc), writing tests, keeping codebase clean and so on. Your question is way too complex to properly answer it on reddit.

You can also post some of your projects to have them looked over - it's not exactly possible for anyone to know what's wrong with their code since well, they don't know that it's a wrong practice. Needs other people to see it.

&gt; and I always forget to declare my variables and arrays at the top my code

You know, this for example isn't a bad practice. Like hell am I going to declare my loop iterators ahead of the time for example.

But for instance order in which you declare methods in a class does matter. I dislike clusterfuck there. I want them ordered - constructors/copiers first, then most important ones, then less etc. Having them grouped up by their type (eg. if you have a math library then you might want to group up all matrix methods in one section). Or even alphabetically.

But as said, your question is way too broad and as such requires a proper reading session.

u/Disastrous_Internal · 3 pointsr/learnprogramming

for the time out, it's usually because you are using an algorithm not optimal.

As for clean code, some of it is general to any language, and you can ready a bunch of book on the subject (like this one https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 )

but you can also look for clean code in python in particular, follow the pep8, read the official guide https://docs.python-guide.org/writing/style/ and on top of that, maybe look for code style as used in big companies (like this one at google https://github.com/google/styleguide/blob/gh-pages/pyguide.md )

u/Pinski47 · 3 pointsr/dotnet

There are two books I always recommend to anyone who is starting their Software Engineering career.

The Pragmatic Programmer: From Journeyman to Master

Clean Code: A Handbook of Agile Software Craftsmanship

Both of these books were recommended heavily to me when I joined the industry and I wish I would have read them sooner. They manage to boil down years of insight and experience into a couple of interesting and thought provoking reads. I always buy copies for my interns or college graduate level junior developers.

In my experience, good .NET code requires much more structure than front end code. These books can help you get into the right mindset of a .NET developer.

u/JosephCW · 3 pointsr/cscareerquestions

Books and when possible building side projects.

List of Java-related books I've found helpful.

Clean Code


Java 8 in Action


Data Structures &amp; Algorithms in Java


Test-Driven Java Development

The last book (Test-Driven Java Development) briefly introduces different testing frameworks for java. It gives you a good start to work off of on your own.


Ninja Edit: I'm also adding two websites that have rather useful examples/diagrams for different design patterns.


DZone


TutorialsPoint

u/digital_superpowers · 3 pointsr/learnprogramming

Most docs aren't going to tell you how to code professionally. I have found that books are the best bet for this, since they're usually composed with a story in mind. Some of these aren't going to be web-specific. But they're still really great.

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

u/Beggar-So · 3 pointsr/cscareerquestions

I'm still pretty inexperienced, so I would LOVE feedback as well!

Code should be self-documenting. Variables, functions, classes, etc. should be named descriptively. Here's a rather contrived example:

if(flag1 &amp;&amp; flag2 &amp;&amp; flag3)
doSomething();

What do the flags, well, actually flag? What are they meant to symbolize? What the hell does doSomething() do? At first glance, I can't tell what the point of this code is.

boolean isHireable = person.isCompetent() &amp;&amp; person.isFriendly() &amp;&amp; person.hasGoodHygiene();
if(isHireable)
addToCandidates(person);

If I leave this project for a year and then come back, I might forget how the underlying implementation works, but at least here, it's MUCH easier to make an educated guess.



Comments should be used sparingly. Unless there's a good reason, you shouldn't use comments to describe your code (remember, your code should be self-descriptive). What happens if the code changes, but the comment doesn't? Then the comment becomes misleading or even incorrect, which can confuse maintainers down the line.

If anything, the comment should reflect the
intention of the code, rather than the code itself. That way, even if the specific implementation of that intention changes, the comment still accurately describes the purpose of the code.

You should also remove commented-out code (use version control instead!). At least in my experience, it can cause a lot of confusion and clutter.



Sometimes you'll find yourself repeating the same or similar code across many different functions. Maybe that code can be extracted into it's own function, and you just call it when you need to.

Try to keep your functions small, they should really only do one thing, and one thing well.



You might also be able to find guides for your specific technologies. For example, best practices for a designing a Java class hierarchy might not apply to handling events in Javascript. Your company might enforce a styling guide or the community surrounding a particular technology might have de facto conventions.



I've also found this book to be a pretty good resource. It's based in Java, but you can apply the principles to a lot of different areas. http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

u/spacemunkee · 3 pointsr/gamedev

This is exactly what I was thinking when reading this. As someone who has been coding and doing code reviews for 20+ years, comments almost always lie eventually. They are an extra point of maintenance and most people don't maintain them when changing code.

As for long functions, your functions should really be doing one thing. A long function is a smell that tells me it is probably doing too much. The more you get into the habit of keeping things small, the more you realize how much easier it is to reason about the code you're writing and reading.

This book by Uncle Bob Martin is pretty great. Am I telling you to change your style? No. But like the person above me, I am imploring you to read more on the subject and come to your own determination.

u/metraon · 3 pointsr/Python

You may want to read Clean Code !

u/shooky1 · 3 pointsr/swift

If you haven't heard of it already,I'd recommend The Programmers Bible. The one and only book you'll ever need for writing consistently clean code.

u/fragglerock · 3 pointsr/programming

There is a book for that!

https://www.amazon.co.uk/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052

Where legacy code is defined as code not protected by tests. Really great book.

u/thamesr · 3 pointsr/java

If you ever work with an older codebase, check out "Working Effectively with Legacy Code".

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

Getting older code under test is some of the most challenging (and rewarding) work you can do.

u/bigboehmboy · 3 pointsr/programming

If you're looking for a good book on this subject, I'd recommend checking out Working Effectively with Legacy Code. It's 90% about unit testing, but offers a lot of great advice.

u/manys · 3 pointsr/learnprogramming

This book is the (or a) bible for this.

Generally: you start at tests.

u/jasonswett · 3 pointsr/rails

&gt; I am a relatively new to development

If you're new to development, it's hard enough just to learn Rails by itself. In addition to the Rails concepts (e.g. ActiveRecord, view rendering, etc.) there's Ruby, databases/SQL, servers, HTML, CSS and JavaScript. Even if you're already comfortable with all those things, it's pretty hard to throw testing into the mix. When I first got started my question was, "What do I even test?" Do I write unit tests? Integration tests? View tests? Controller tests?

My advice would be to forget about Rails for a little bit and just practice testing Ruby by itself for a while. Then, once you're comfortable with testing Ruby, it will be easier for you to go back and try to write some tests in Rails.

&gt; What is your recommendation on if I should focus on rspec vs minitest?

A person could make technical arguments for either. Deciding which testing framework to use depends on your objectives. If you're teaching yourself testing to become a more marketable developer, then I would definitely recommend RSpec. Almost every Rails project I've worked on (20+ production projects) has used RSpec. Having said that, it's less important which tool you choose and more important that you have a solid understanding of testing principles. I personally chose RSpec and I'm glad I did.

Here are some testing resources I often come across:

Growing Object-Oriented Software, Guided by Tests (awesome book, highly recommended)

Rails 4 Test Prescriptions (just started it, seems good so far)

Working Effectively with Legacy Code (super good book and more relevant to testing than it might seem like)

Everyday Rails Testing with RSpec (haven't bought it yet but seen it recommended a lot)

Destroy All Software (just bought it today, seems good so far)

Lastly, I myself created what I call a Ruby Testing Micro-Course designed to make it easy for people like you to get started with testing. Feel free to check that out and let me know what you think.

u/comp_freak · 3 pointsr/cscareerquestions

Yes, it's true that writing unit test for legacy project is hard. But what I have done is when implementing new feature I start using Sprout Method or Sprout Classes which are unite tested. This allow me to know that the new features I added is unit tested and works as expected. It will not be easy at first as you have to find seams or create seams for testing. But once you start doing it each time you touch the project it's get little better. Once you have something decent show it to your team and they will love it.

I found that code get uglier as there are many small classes but it's easy to maintain.

If you haven't read, I would suggest you to check out Michael Feathers' Working with Legacy Code.

u/seventeenninetytwo · 3 pointsr/programming

"Call out" also means to make reference to, especially in the context of a book where you might "call out" a figure, phrase, or common theme. This is how it was used above.

This is the book. Next time when you don't know, just ask.

u/StealthRabbi · 3 pointsr/computerscience

Working as a software engineer, you will inevitably inherit some code that is less than stellar and not designed for unit testing. This book is very effective and teaching techniques to overcome pitfalls with legacy code.

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

u/seglosaurus · 3 pointsr/ProgrammerHumor
u/bzBetty · 3 pointsr/agile

Iirc https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052 was a pretty good book and gave lots of hints on how to refactor legacy code to make it easier to replace. Been a while since I've read it though.

u/snarkyprogrammer · 3 pointsr/cscareerquestions

Sadly there are a lot of companies that operate like this and I wish I could say this isn't common , but it is, especially around non technical companies that do in-house development. However, there are lots of companies changing and trying to improve their process and code base.

Working with legacy code is something every developer has to do at some point. There are techniques to make the process easier. Checkout the book Working Effectively with Legacy Code

Also, try and follow the boyscout rule of programming. Always leave the code base slightly better than you found it. You don't have to go crazy, but little improvements here and there. Test the new code you write and over time you'll have a much cleaner and better system.

I used to work on a web application that was so horribly coupled together that any small change literally break the whole thing and cause hours of debugging. I know your pain.

u/alpha_hxCR8 · 3 pointsr/learnpython

Object oriented programming is a deep topic.

If you are looking for a simple introduction, I found Chapter 8 of this book, which is also used for the MIT Intro to Programming using Python pretty good.
https://mitpress.mit.edu/books/introduction-computation-and-programming-using-python-0

If you want to dive deeper, these 2 books have good descripts of OOP and other fundamentals of Programming. However, these are not specific to Python, but are probably the most recommended books in programming:

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

  2. Code Complete: https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
u/siphilis · 3 pointsr/javahelp

It sounds like you could really benefit from reading Clean Code. It isn't really about a specific design pattern, but an overall design philosophy. It gets mentioned in the programming subreddits all the time, and for good reason. I haven't finished it yet, but it's already had a big positive impact on the way I think about, and design my code.

u/OrionSuperman · 3 pointsr/cscareerquestions

Everything helps with new grads. Internships definitely help, and remember to have listed which technologies and services you used during that time.

If you want to really set yourself apart, take a look at Clean Code. Being able to skip the 'the code works but is entirely unmaintainable' aspect of a new college grad training is a huge plus.

u/duderbats · 3 pointsr/learnprogramming

I truly believe that everyone should have read "Clean Code" by Robert Martin atleast once! Hiigly recommended:
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?ie=UTF8&amp;amp;qid=1465858366&amp;amp;sr=8-1&amp;amp;keywords=clean+code

u/zoug · 3 pointsr/Omaha

15 is really young. If you're relatively presentable, you might want to try Hyvee.

That said, it looks like from your profile that you have an interest in math and coding.

If this is something you're naturally skilled at, you shouldn't be working in fast food. You should be ignoring temporary financial gains to put yourself in the best place possible for college and technical internships.

The primary way to do that is to double down on your academics. At 15, you'll probably be going into your sophomore year? Don't accept any grade but an A from here on out. There's just no reason for it. You're obviously not retarded and school is easy.

Grab an ACT/SAT prep book. Take every practice test you can find until you get your scores into the absolute highest percentile you're able to.

If available, join a cyber academy, coding, math or robotics club at your school.

Go to things like this:

http://siliconprairienews.com/2014/08/meca-challenge-2014-preview/

Read books like these:

http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/The-Pragmatic-Programmer-Journeyman-Master/dp/020161622X
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882


You'll lose a few thousand dollars over the next few years from working a shit job but you'll also be able to get a technical internship as soon as you turn 18 making double/triple minimum wage, while you gain proficiency in a relevant field.

You'll also go from $Texas in student loan debt to a free ride, saving you 30,000 to 100,000+ depending on what school you can get into on scholarship.

You may be 15 but I have to disagree with anyone else that you're only worth minimum wage. Everyone has skills they can work on and if you really want to help your family in the long term, work on what will make you successful.

If you have any questions regarding any of this, PM me.








u/htfo · 3 pointsr/PHP

Try as hard as you can to match the principles of [SOLID design](http://en.wikipedia.org/wiki/SOLID_(object-oriented_design%29). Each principle has relatively straightforward rules to follow, and you should have to justify to yourself why you need to break any of them before doing so.

Coming to terms with SOLID design alone will help minimize a lot of problems and help you think differently about writing more maintainable code, but here are some other tips:

  • Minimize branching: if you're using long strings of if/elseif/else blocks, it's a fairly good sign that your function/method is doing too much. Again, there should always be a solid justification for doing that instead of breaking it up into more manageable chunks.

  • Let exceptions bubble up as far as possible: if you're catching exceptions immediately just to log it or display an error message, let them be thrown and catch them all at a higher layer. Similarly, if you have no meaningful way to handle an exception in context, don't catch it.

  • Minimize nesting: a good rule of thumb is to avoid indenting more than once or twice in a method or function unless you have a really good reason to. Practically, this means things like returning immediately if a condition fails instead of wrapping the rest of the code in an if block or breaking out nested logic into their own functions/methods.

  • When a function or method goes past 10-15 lines, start thinking about how to break it up. Is it violating the single responsibility principle? Is there code that can be reused elsewhere?

  • Start looking into design patterns. An algorithm or structure that you came up with on your own and takes 300 lines may be better solved by a pre-existing design pattern that only takes 20. A good place to start is the Gang of Four's Design Patterns. It's pretty dated in its code examples (uses Smalltalk), but it gives a point of reference to know what to look for when finding more up-to-date examples.

    Finally, check out the book Clean Code by "Uncle Bob" Martin, which goes into a lot of the above and more in more detail.
u/cannibalbob · 3 pointsr/cscareerquestions

The feedback about "jargon for development" can be solved by going through some books cover to cover, making sure you understand the theory, and implementing the exercises. I understand that feedback to mean that the person who gave the feedback believes there is too high a chance you will inflict damage on the codebase by making decisions not grounded in solid theory.

Examples of titles that are classics and widely known:
Algorithms (4th Edition): https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X (there is an accompanying coursera course).

Code Complete: https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=sr_1_1?s=books&amp;amp;ie=UTF8&amp;amp;qid=1469249272&amp;amp;sr=1-1&amp;amp;keywords=code+complete

Clean Code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?s=books&amp;amp;ie=UTF8&amp;amp;qid=1469249283&amp;amp;sr=1-1&amp;amp;keywords=clean+code

Functional Programming in Scala: https://www.amazon.com/Functional-Programming-Scala-Paul-Chiusano/dp/1617290653/ref=sr_1_2?s=books&amp;amp;ie=UTF8&amp;amp;qid=1469249345&amp;amp;sr=1-2&amp;amp;keywords=scala

Learning Python: https://www.amazon.com/Learning-Python-5th-Mark-Lutz/dp/1449355730/ref=sr_1_1?s=books&amp;amp;ie=UTF8&amp;amp;qid=1469249357&amp;amp;sr=1-1&amp;amp;keywords=learning+python

Effective Java: https://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683/ref=sr_1_5?s=books&amp;amp;ie=UTF8&amp;amp;qid=1469249369&amp;amp;sr=1-5&amp;amp;keywords=java

Haskell Programming From First Principles: http://haskellbook.com/

I included multiple languages as well as language-agnostic ones. Functional programming is the near-to-medium term future of software engineering, and most languages converging towards that as they add functional features.

I don't think bootcamp is required. Learning how to learn is the most important thing. If you get into these books, lose track of time, and feel "aha! that's how these things that I previously thought were unrelated are actually the same thing!", and are able to keep it up for weeks, then that is a good sign that you can get to where you want to be.

u/jreborn · 3 pointsr/learnprogramming

I'm self taught and it definitely is not a myth. To add to the top comment, you might want to give this a read as well:

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

u/jefidev · 3 pointsr/SoftwareEngineering

Hello,

From my experience, the tool selected for a project will always become the wrong choice after a certain period of time. It is never obvious which tool is the best at the beginning of a project. An experimented team will more likely make reasonable choices but they should always keep in mind that the tool they use will be replaced at some points or modified. That's why architecture and good coding practice are the cornerstones of a project able to withstand evolution.

I had to work, one day, on the transition from SQL to MongoDB. There is no magic, all the code calling the SQL data source had to be rewritten. It is a costly process but the final cost of the operation mainly depends on how well the calls to the database are isolated from the rest of the software.

Sadly, I don't have any tools for handling this specific case. But I can recommend those books :

  • For your team it could be interesting to read Clean Code : Some of the approaches of this book could be contested, but globally the essence of what it teaches is useful for designing good evolving software
  • For a manager I recommend Project Phoenix : It is a fiction about a company struggling to manage its IT and how the new CTO tries to overcome those issues. It is a good fable with a lot of lesson for IT management.
u/curious_webdev · 3 pointsr/compsci

Not all on topic as "CS" books, more general programming, but here's a short list. I also suggest the opening chapter or two of a lot of books for stuff you don't know but are interersted in. They're generally just nice easy to read introductions.

u/Andrew_Shay · 3 pointsr/learnpython

The book Clean Code will help with improving your code in general.

Head First Design Patterns is great! But in Java. The patterns still apply to Python though.

Here are patterns in Python https://github.com/faif/python-patterns

u/jcbbjjttt · 3 pointsr/learnprogramming

I've been programming for 23 years now. I was originally self taught and have worked with many people who are self taught. In my opinion, working with people who are self taught is usually a much better process than someone who has only ever learned from school based assignments. Since you were never told otherwise but you are super motivated to make things work, being self taught can definitely leads to many bad habits.

For example, the very first game I wrote was in BASIC and I didn't know about loops or subroutines. The entire logic of the game was written using a 10,000 line block of if elses which described all possible ways the game could play out. However, I did eventually learn about subroutines and loops and am constantly looking to improve my code. That is the key piece that you need to remember and put forward when working with others. Let them know that you're always looking to improve yourself. Try not to get defensive about your work if it is criticized. Instead, explain why you chose to do something that way and ask for suggestions on improvements.

It sounds like you're on the right track already and that given time, you'll be a top notch hacker. Keep pushing yourself to improve and refactor your code.

Two books that could be useful for you to start with writing / rewriting code to be cleaner and more professional.

Clean Code
Refactoring: Improving the Design of Existing Code

Best of luck!

u/Elongatedappendages · 3 pointsr/UnethicalLifeProTips

By making things and putting them on GitHub, and then you can link to your GitHub portfolio on LinkedIn. Any company worth working for will care more about the quality of your work than your certifications.

If you're asking how to learn programming in the first place, it has never been more accessible! There are countless books and guides out there for any topic imaginable. So what I told apprentices at the last company I worked was, start by reading Clean Code by Bob Martin, to get a feel for the mindset with which to approach programming.

And from there, just start making stuff-- 'Breakable Toys' we call them. After print(&quot;Hello World&quot;) the first thing I made was an unbeatable tic-tac-toe game, and then a bunch of other random stupid stuff before I learned to do anything interesting or marketable.

OPINIONATED STATEMENT ALERT: You must make your first project in Elm! :) it's by far the most beginner-friendly language I've ever worked with, and really just an overall delight (even for non-beginners). Even though it's not the most marketable language right now, it's the best intro you could have into programming, and will give you a great foundation to learn other languages!

Edit: Also worth looking into apprenticeship opportunities. The only well-known one I can recommend in good faith is 8th Light's which I believe is free until they start paying you-- so a better deal than college I would say! Thankfully, many smaller local businesses are starting to embrace the apprenticeship model as well, so keep those opportunities on your radar.

u/ThereKanBOnly1 · 3 pointsr/csharp

So I don't think you should get too hung up on "enterprise architecture" at the moment, partially because you're still very early in your career, but also because enterprise architecture means a lot of things to a lot of different people. At this stage in your career, I really think you should focus mainly on SOLID code, core Object Oriented design concepts, and then understanding patterns. Good architectural strategies are built around all of those concepts, but they're also much much more than that.

For SOLID code, one of my favorite references is actually Dependency Injection in .Net by Mark Seemann. Although he does spend a good amount of time on DI, the recommendations that Mark makes for how to properly structure your code in order to take advantage of DI are very useful in understanding SOLID oriented design principles in general. The examples and code really work through the concepts well, so you get a great explanation followed by some well thought out code.

Clean Code by Uncle Bob is a great reference on how to structure well thought out code that touches on some architectural principles, but doesn't have that as the main focus of the book. Many of the topics in the book you'll find need to be addressed throughout a codebase.

As far as design patterns (which are different then architectural patterns), I don't think you can go wrong with the original Gang of 4 book , although I personally have a C# specific version, C# Design Pattern Essentials. I don't want to put too much emphasis on design patterns, because sometimes they get overused and applied too literally, but they are still very useful. I think the key to design patterns is not just knowing what they are, but determining where they might be applicable to your use case, and whether you should make any small adjustments or tweaks to them.

After you really have a rock solid base of working with code, then you can shift your focus on more architectural concerns. For that, it really depends on what problem your looking to solve, but Domain Driven Design (DDD) is a good way about understanding those problems and to structure the solutions in a well thought out, loosely coupled, and evolvable manner. That "central framework" that you referenced in your post is the business logic, and its the key focus of DDD

u/romple · 3 pointsr/learnprogramming

Well, if I were evaluating this in an interview these would be my thoughts:


I don't like one letter parameters like String s. It's pretty obvious here since there's only one parameter and the method name tells me what's going on, but this can lead to unreadable code for larger methods with more parameters.

The 0 length string guard at the start is nice, although necessary here. Unnecessary code makes things cluttered and less readable.

The if(!p.equals(&quot; &quot;) ... statement is unnecessary. When you split the string it should essentially remove any white space. When reading code a lot of time is often spent on interpreting complicate predicates, so it's good to remove unnecessary ones or abstract it out into a method. Unnecessary code makes things cluttered and less readable.

if (!p.equals(&quot; &quot;) &amp;amp;&amp;amp; !p.equals(&quot;&quot;)) could easily be a method isValidWord(p), which lets me read the flow of the statement without necessarily reading the innards of what a valid word is. I can do that later, but right now I just want to understand the logical flow of what's happening. Again here, it's fairly obvious, but when things are more complicated and validation criteria are more convoluted these are good abstractions to make.

stack.push(p.trim()); again seems redundant. There won't be any padding whitespace when you split the string to an array. Removing unnecessary code leads us to

for (String p: parts) {
stack.push(p);
}

Also, while we're here, why p and not part? If you're trying to go full on readability, one letter variables are basically outlawed except as indexes.

for (String part: parts) {
stack.push(part);
}

While we're still here, why parts and not words? Words is more descriptive of what the variable represents. You always want descriptive variables. The goal of clean code is generally readable code. Although part could be argued as appropriate here. Word just conveys more meaning to me.

I don't know if you were told not to use existing APIs, but taking advantage of existing abstractions makes code more readable in general. For instance

public static String reverseWords(String s) {

List&lt;String&gt; words = Arrays.asList(s.split(" "));
Collections.reverse(words);
String reversedString = "".join(" ", words);

return reversedString;
}

Just looking at the above you can pretty much tell what's happening. We have a List of words, we reverse it, then join that list into a string. you can even abstract out more things, but this is probably overboard. But if we go down that route you essentially have 3 lines of code to read to understand what your logic is. Build a list of words from a string, reverse it, then join that list together into a string.


public static String reverseWords(String s) {

List&lt;String&gt; words = buildListOfWordsFromString(s);
Collections.reverse(words);
String reversedWords = joinListOfWordsToString(words);
return reversedWords;
}

private static String joinListOfWordsToString(List&lt;String&gt; words) {
return "".join(" ", words);
}

private static List&lt;String&gt; buildListOfWordsFromString(String s) {
return Arrays.asList(s.split(" "));
}


Anyway, these are just my thoughts and people will disagree. This is still one of the best books to read if you're interested in writing more readable code.

u/david72486 · 3 pointsr/java

I can definitely recommend 3) and 4) for sure. 2) has a particular style - many people enjoy it, some might not, so read a few pages first.

I'm not personally familiar with 1) and 5).

I will also add Clean Code for design patterns and general organization. If you're a beginner, it's probably okay to take that book at face value. However, once you get more advanced, you'll discover the parts where you can bend/break the strict rules he sets up there.

u/FizixMan · 3 pointsr/csharp

If you find you have too many if branches, it may be a sign to refactor/reorganize that section of code. Move work to separate, nicely named methods; move branching logic to a separate method; move conditionals to methods. Perhaps throw the whole thing into a separate helper/utility class. Your goal should have your high-level code stating what it wants to do, now not how it does it.

If you're looking to improve your code readability and craftmanship, I'd suggest maybe you pick up a good book, perhaps Clean Code. I found that book really elevated my game and perception of things. I can't recommend every style described in that book; you should read it, learn, look at code in new ways, and do what makes the most sense for you and your fellow developers that you work with.

EDIT: a typo

u/machuu · 3 pointsr/learnprogramming

Robert "Uncle Bob" Martin has produced a lot of good material on exactly this subject.

You could start with one of his books Clean Code: A Handbook of Agile Software Craftsmanship

He has some other books, and a website cleancoders.com

u/cybernd · 3 pointsr/AskProgramming

Book recommendation:

  • Clean Code

    Chapter 4 is dedicated to code comments and will help you to understand why some people are talking about self documenting code.

    I also recommend you to remember the books author. He also calls himself "Uncle Bob" and you will find several good talks from him on youtube. (Warning: they usually start with some minutes of a completely unrelated topic)

    If you take developing software "serious" i would declare reading this book as mandatory. The same goes for his talk about "Expecting Professionalism".
u/diisiqueira · 3 pointsr/brasil

Cara, reinventar a roda não é ruim! Resolver problemas clássicos é uma ótima maneira de aprender e praticar é a melhor maneira de melhorar em algo. Eu sou o tipo de cara que gosta de aprender as coisas na prática então sou suspeito de falar mas vai lá e desenvolve. Essa minha aposta com meus amigos é justamente para nos forçar a isso, desenvolve qualquer coisa mesmo que seja algo completamente inútil, que é melhor do que ficar parado. Umas semanas atrás, nessa aposta um dos meus amigos desenvolveu um script que calculava se era ecologicamente correto urinar no chuveiro ou na privada, utilidade real do projeto é nula, mas fazendo isso ele já começou a aprender uma nova linguagem e investiu tempo em se tornar um programador melhor. Realmente meu conselho é faça, desenvolva! Uma dica é pegue pequenas coisas do seu dia-a-dia e resolva elas com programação, por exemplo, uma vez eu fiz um script que me perguntava quais ingredientes eu queria em um lanche, ai ele varria o site do iFood e me falava qual era a opção mais barata que eu tinha. Não tinha necessidade alguma de fazer isso, era muito mais rápido fazer uma busca manual, mas na época isso me ensinou a usar a BeautifulSoup e foi super divertido de fazer.

  1. Eu sempre tive a visão de que o mercado python no Brasil é bem mais fraco do que em outros países, não sei ao certo de porque, aqui na minha região por exemplo não conheço nenhuma empresa que seja especializada em python. Por outro lado aqui o grande foco das empresas é o PHP, em todos os níveis. PHP é realmente uma linguagem de entrada, por ser muito aberta e deixar a pessoa fazer as coisas de qualquer maneira, acaba sendo muito fácil de tornar uma pessoa capaz de criar códigos funcionais em PHP, depois quando aprendem melhor o paradigma da programação, muitas acabam migrando para outras linguagem.

  2. Atualmente eu tenho dois livros que ficam grudados na minha cabeceira da cama, e leio um pedaço todos os dias quando acordo, são eles o Clean Code e o Design Patterns. Tambem to de olho no The Pragmatic Programmer.

u/smdaegan · 3 pointsr/Archery

Yeah, and that's largely the problem when software engineers run into "academic" code -- the conventions used are all mathematical or physics-type nomenclature, but it makes it almost impossible to read/follow for someone that's used to reading code, if that makes sense.

There's a fantastic book called Clean Code that talks about how to just write code better and in a more readable manner. It's pretty readable by people with any level of coding knowledge, and I'd highly recommend it should you ever want to cross into the realm of software as a profession, or as a more serious hobby ☺

u/Luonnon · 3 pointsr/rstats

If you're moving from academia, chances are any code you've written has been to get the computer to do something. Software development is more about writing code for other people to read and work with... which also happens to do what you want it to do. You might want to make sure you have the basics of software engineering practices down by reading Code Complete and Clean Code: A Handbook of Agile Software.

Beyond that, if you have a solid project or two that you can talk about the ins and outs of, it shouldn't be hard to convince a company that you can analyze data and write code to automate or otherwise help with that process.

u/KlaireOverwood · 3 pointsr/learnpython

There are books and articles on the subject (recommendations welcome).

A good advice is to keep in mind (or imagine) that the code will have to be changed. Maybe in a year, maybe not by you - this is very common in "real life". For example, of you have 128 of something to process or a limit of 128 that appears often, write N = 128 and then use only N, this way, if/when the limit changes, you'll have to change in one place. Keep code as modular as possible: if there is getting data, processing the data and displaying the data, keep these as separated as possible - no processing during displaying. This way, if/when you'll have to display it otherwise or somewhere else, you'll change the displaying code, but the processing will stay where it was: out of sight, out of mind.

Then there's code review, not for the faint of heart, as it's 99% negative feedback, because it lists things that need to be changed and improved and doesn't focus on the good ones. But this is very "real life": you can't get attached to your code, it will be ciritised and it will be deleted, it's a stepping stone and not a work of art. (Take pride in what the project does and the difficulties overcame. It can be a challenge to keep your head up high in this job, since you're always working on the things than need fixing, not the ones that are done and working.) If you want, you can send me a sample to review.

Finally, the appropriate xkcd.

u/stdio_h · 3 pointsr/csharp

Pieces of your app should be able to change without considerable changes to the whole.

research solid principles:
http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29

research a layered architecture:
http://layersample.codeplex.com/

try this link for sqlite:
http://brice-lambson.blogspot.com/2013/06/systemdatasqlite-on-entity-framework-6.html

also, if you are in school, complete your assignments, but other than that
do not write another line of code until you have checked out (at least read the chapters on writing classes and functions):

Clean Code

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

and Code Complete

http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

u/uberhaxed · 3 pointsr/learnprogramming

Is there a point to doing this early? When you get an entry level position you will learn all of this and more. Also you seem to be missing a small detail. A team doesn't just consist of engineers. There will be a set of non-engineers on your team whose sole purpose will be planning, issuing work, documentation, etc.

That said:

&gt; I would like to learn how to work on a software development team and whatever that entails.

The only place you can get this is on a software development team in industry. Much of the industry have agile processes for scrum, issue tracking, etc. but those are really to manage large teams for largely divided projects. If you are working with a couple of friends then the best thing to do is peer program when you can and code review when you can't. If you plan to make a start-up, then it might be best to get some one to do the managerial work. If you're insistent on doing it yourself, then you'll really end up spending most of the time manage the project rather than writing code, which means you're basically just a manager anyway.

But if you insist anyway, here's some books:

u/sh0rug0ru____ · 3 pointsr/java

Read Clean Code. Uncle Bob's advice is to keep methods to around 10 lines long. The reason is that any longer than that and you're almost certainly mixing levels of abstraction and you have to keep a lot more in your head when reading the code. He advises ruthlessly using the Extract Method refactoring, but tease out abstractions as you do. Your methods should "read well", like a recipe from a cookbook, with details captured in aptly named helper methods.

u/Balduracuir · 3 pointsr/java

That line of code you showed violates more Interface segregation principle than Single responsability to me.
It's not because everyone is using something that it is a good practice... You can try to spread the good word around you and encourage people to read or re-read Clean code for example.

u/KevMar · 3 pointsr/PowerShell

There are a lot of good answers in there already. Clean Code is one book that I read that I feel really changed the way I think about and write code. It's not PowerShell, but the ideas apply to any language and the code examples are easy enough to read.

u/thesystemx · 3 pointsr/java

DON'T COMMENT!

Comments should be placed only where it explains something that's not clear by the code itself. Commenting getters and setters buys you nothing, unless they have some side-effect the user should be aware of (but then again, they should not have such side-effect in the first place).

Clean Code (http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) has an entire chapter devoted to this.

Btw, please also format your code normally. What you 're doing now with those weird bracing style is atrocious!

u/leftnode · 3 pointsr/PHP

Thanks! Yeah my opinion isn't popular around here because PHPer's love their docblocks.

The book that changed my mind about them is Clean Code by Uncle Bob Martin. The book is simply amazing, a quick read, and tells you what you already know, but in an articulate way.

Two things in there that really shake up a lot of Java/PHP programmers is his view on method length and docblocks.

Regarding method lengths, he maintains that a class method should be no longer than 4-5 lines. Any longer and it needs to be split into another method because it's probably doing more than one thing (a method should do one thing only). I find this one the hardest to comply with because it requires a great deal of discipline. But boy, when you do comply with it, your code is so much easier and cleaner to read.

Obviously, this goes for programmers working on systems where resources are virtually unlimited (99.99% of all PHP programmers). An embedded programmer probably has to watch how many methods/functions are pushed onto the stack, but programmers making web apps don't need to (as much) because resources aren't as tightly controlled.

Regarding docblocks, he says they're entirely useless, and I agree completely.

For example, this is useless:
/**

  • The ID of the user.
    *
  • @type integer
    */
    private $user_id = 0;

    Why is that docblock completely useless? Because it's told me nothing about the variable, and nothing that couldn't be gleaned by looking at it's definition:

  • It's name is user_id so the description is useless. If it holds something other than the ID of the user, then you're really in trouble.
  • By it's default value, 0, we can tell it's an integer.

    So now you've wasted 5 lines of code (not that they're a precious resource or anything, they just clutter up the rest of your code) to describe a variable that's obvious from it's name and default value.

    If you need a docblock to describe a method, that's just as bad because it means you can't deduce what the method does by it's name and arguments.

    Taking the only PHP project on the front of Github, let's pick a random file and pick it apart (sorry CakePHP, don't take this personally): https://github.com/cakephp/cakephp/blob/master/cake/libs/i18n.php

    Look at the method translate(). It should be pretty obvious what the translate() method does in an i18n class. Picking apart the docblock:

  • The fact it can be used statically or through an instantiation is another issue that should be remedied.
  • Any decent editor can pick up the argument list just from looking at the definition (and re: the $count variable, that's a bad name because it's not very descriptive at all. $pluralFormCount would've been better, more descriptive and now doesn't require the description, however, it uses a magic number (6?) and that's another issue)
  • We know it's public because it's not described as private
  • We know it returns a translated string (again, if it doesn't, you have bigger problems)

    Next, look at the clear() method. The docblock is longer than the entire method and it tells me nothing useful.

    clear() is a poor name because it doesn't describe what it clears. clearBuffer() or clearTranslations() would've been a much better choice. It says it's useful for testing, but not why, so that's a useless comment, and it doesn't @return void, it returns nothing, so that's a misleading docblock.

    Which brings me to another point: updating docblocks. It takes a lot of discipline to do so. I'd much rather concentrate my discipline on writing clean and clear code, unit testing, and writing good documentation outside of my code than keeping a bunch of docblocks up to date.

    Thus, in summary: docblocks cloud your code and make it harder to read while adding nothing.
u/root_pentester · 3 pointsr/blackhat

No problem. I am by no means an expert in writing code or buffer overflows but I have written several myself and even found a few in the wild which was pretty cool. A lot of people want to jump right in to the fun stuff but find out rather quickly that they are missing the skills to perform those tasks. I always suggest to people to start from the ground up when learning to do anything like this. Before going into buffer overflows you need to learn assembly language. Yes, it can be excellent sleep material but it is certainly a must. Once you get an understand of assembly you should learn basic C++. You don't have to be an expert or even intermediate level just learn the basics of it and be familiar with it. The same goes for assembly. Once you get that writing things like shellcode should be no problem. I'll send you some links for a few books I found very helpful. I own these myself and it helped me tremendously.

Jumping into C++: Alex Allain

Write Great Code: Volume1 Understanding the Machine

Write Great Code: Volume2 Thinking Low-Level, Writing High Level

Reversing: Secrets of Reverse Engineering

Hacking: The Art of Exploitation I used this for an IT Security college course. Professor taught us using this book.

The Shellcoders Handbook This book covers EVERYTHING you need to know about shellcodes and is filled with lots of tips and tricks. I use mostly shells from metasploit to plug in but this goes really deep.

.

If you have a strong foundation of knowledge and know the material from the ground-up you will be very successful in the future.

One more thing, I recently took and passed the course from Offensive Security to get my OSCP (Offensive Security Certified Professional). I learned more from that class than years in school. It was worth every penny spent on it. You get to VPN in their lab and run your tools using Kali Linux against a LOT of machines ranging from Windows to Linux and find real vulnerabilities of all kinds. They have training videos that you follow along with and a PDF that teaches you all the knowledge you need to be a pentester. Going in I only had my CEH from eccouncil and felt no where close to being a pentester. After this course I knew I was ready. At the end you take a 24-long test to pass. No questions or anything just hands on hacking. You have 24 hrs to hack into a number of machines and then another 24 hours to write a real pentest report like you would give a client. You even write your own buffer overflow in the course and they walk you through step by step in a very clear way. The course may seem a bit pricey but I got to say it was really worth it. http://www.offensive-security.com/information-security-certifications/oscp-offensive-security-certified-professional/

u/xgamerx · 3 pointsr/programming

Yeah and let's be honest; how many books are irrelevant as quickly as they are published (especially for fast-moving topics like Android and iOS). Often the book is dated before it even hits the shelves for these types of topics. To be clear, I'm not saying there isn't any value in books (I often recommend Professional Android 4). Just that often other resources are often better suited for rapidly changing topics.

u/jtreminio · 3 pointsr/PHP

&gt; How do I learn all the technologies that have emerged out in the recent years?

Slowly.

Read. Books, large projects, small projects, blogs.

I wrote something on PHPUnit.

I wrote something on XDebug.

I wrote something on Composer.

Frameworks aren't for learning how to write PHP. You should already know PHP pretty well before deciding on using a framework. If you try to learn OOP through using a framework you're Going To Have a Bad Time.

Read this to figure out what a framework actually is and what it's for.

If you're not very familiar with how to use OOP, read /u/ircmaxell's blog, from the beginning.

If you need to actually gain more in-depth understanding of OOP, read this and then this.

u/sarcasticbaldguy · 3 pointsr/dotnet

Pro Asp.Net MVC is a decent book that will walk you through building a functioning site from scratch.

u/CaptainBlood · 3 pointsr/dotnet

The default recommendation seems to be Adam Freeman's Pro ASP.NET MVC books from APress. It's what I chose and I think it does a great job.

http://www.amazon.com/Pro-ASP-NET-Experts-Voice-ASP-Net/dp/1430265299

u/psychfi · 3 pointsr/AcademicPsychology

Lots of great suggestions here. My grad program used SPSS but it annoyed me that someone had to pay for it, so I learned R. Like others mention, if you learn R it can be easier to go back to SPSS. Also, others who use SPSS might think you have some kind of superpower.

Like u/bobbyfiend says, the best is to do use it on some projects. This forces you to learn something that is important and you have interest in solving. The internet is amazing, and most answers in some form or another can be found on Stack Overflow (make sure to ask the questions in the proper format and search first), /r/rstats (a bit more friendly than stack overflow), or on some of the email lists.

In general, I would say there are a couple of resources that most people could benefit from as they start to learn:

-Andy Field's Discovering Statistics with R - It does have some irreverent humor, but is a good read

-Hadley Wickham's R for Data Science - this resource is free online but can also be bought through Amazon. Hadley is a R celebrity responsible for creating the 'tidyverse' series of packages - packages which make R more beginner friendly imo.

You will definitely want to look at your subspecialty and see if there are any people working in R there. They may have some other resources. Again, you can read books and watch courses all you want, but it is critical to practice (and practice using something you are interested in can help exceptionally). Ultimately, I used my dissertation as an excuse to dive into R - there was pain, and I probably could have done it quicker if I stayed in SPSS - but I learned a lot and now use R and Rmarkdown - and really do not think I plan on going back. Another user mentions looking at others' code, and this has also helped me to make my code more efficient and reproducible - a big strength of R (love that you can use Git).

u/ResidentGinger · 3 pointsr/IOPsychology

Second Tabachnik &amp; Fiddle along with Hunter &amp; Schmidt

Rogelberg's IO Handbook

Brannick &amp; Levine's JA text

HLM - Raudennbush &amp; Bryk

Ployhart et al's Staffing Organizations

I have lots of other O-oriented things, but those will depend on your specific area.

Edit: This!

u/Bjarkwelle69 · 3 pointsr/badeconomics

&gt; Maybe pick up a book and try to learn a little bit of R this summer?

Coursera has online courses if you want learn R and how to do statistics using R.

If you prefer a book, try "Discovering Statistics Using R" by Andy Field. I'm using it to self-study right now and I highly recommend it. It really explains statistical concepts well and it's very easy to read. Although it does sacrifice a lot of mathematics, you could compensate for it when you take up your statistics subject.

I do have to say that I've already taken up Econ Statistics and Econometrics (I had a horrible time however). Also, I've taken up the R course in Coursera so I'm not sure if my experience with the book is the same as yours. Read a couple of chapters and see if it is to your liking.

u/MrDominus7 · 3 pointsr/GradSchool

Discovering Statistics Using R by Andy Field is probably your best bet. It's pretty comprehensive in terms of what it covers and is easy (and enjoyable) to follow along with and understand.

u/mr0860 · 3 pointsr/statistics

I found Andy Field's Discovering Statistics Using R to be quite helpful.

u/Aeyoun · 3 pointsr/Astroneer

System Era Softworks are looking for C++ developers, so your information seems accurate.

I’d recommend you start out [playing around(https://www.amazon.com/Python-Cookbook/dp/1449340377) with Python before committing to C++. It’s much easier to achieve to some tangible goals. Maybe start out scripting some simple tasks. E.g. create ten files that each contain their own creation date and file path. Then progress through making some short text-based multi-choice adventure game (Gender-Neutral-Internet-Person and the Quest for the Reddit Upvotes). Start out simple and see if you enjoy the challenge before committing to learning C++ through game development.

P.S.: System Era lists familiarity with Python as a desired skill. It’s still relevant for automating tasks and getting stuff done even when you learn more complex languages.

P.P.S.: Python 3 is the right choice. 2.7 is an outdated dialect. You’ll know what this means soon enough.

u/ProfJustin · 3 pointsr/Accounting

&gt; https://www.amazon.com/Python-Cookbook-Third-David-Beazley/dp/1449340377
&gt; Also start watching every video David Beazley has on YouTube. You won’t regret it.

Got it!

u/dtizzlenizzle · 3 pointsr/Accounting

https://www.amazon.com/Python-Cookbook-Third-David-Beazley/dp/1449340377

Also start watching every video David Beazley has on YouTube. You won’t regret it.

u/objectified · 3 pointsr/Python

If you're just starting out, you will want to read Learn Python the Hard Way

If you want to learn to do thing the "pythonic" way, I've found that Idiomatic Python is a very good book.

If you already know Python and you want to learn about a wide area of subjects that can be dealt with in Python, I recommend the Python Cookbook. While some cookbooks are somewhat shallow, this book is very different. It provides extensive and very practical information even on complex topics such as multithreading (locking mechanisms, event handling, and so on). It's really worth it.

Also, don't forget to simply read and embrace the pep8 guidelines. They really help you produce good, maintainable Python code.

u/Mr_Toyota · 3 pointsr/cscareerquestions
u/tanyaxshort · 3 pointsr/gamedev

For game DESIGN, I personally like A Book of Lenses and Rules of Play. I didn't get much out of Theory of Fun, and the internet seems to like Level Up! but I haven't read it.

And none of those teach you really about game DEVELOPMENT -- the process, gameplay architecture philosophies, the pipelines, the team structures, the milestones, the industry jargon. The closest I've seen to that is having a games producer de-code chapters of Rapid Development for how it relates to games, back before I joined the industry and had my trial by fire. :)

Do you know what kind/platform/genre of game you're making, and what size the team is?

u/HexCC · 2 pointsr/ReverseEngineering

Thanks for the list. I've been recommended Reversing: Secrets of Reverse Engineering by a friend but it didn't make this list. Does anyone know why?

u/MHHH_SALTY_BALLS · 2 pointsr/gamedev

Even if you don't plan on writing your bots in C/C++, you should still understand how most commonly used compilers compile them to native code.
Most games* are written in C/C++, although .NET ones seem to be gaining popularity.
Once again, assuming Windows, it's usually enough to know how MSVC works.

It's hard to summarize what exactly is 'necessary', as a lot of this comes with experience and some trial &amp; error, but I'll try it anyway:

u/sanitybit · 2 pointsr/netsec
u/arvindsraj · 2 pointsr/netsecstudents

Reversing: Secrets of reverse engineering by Eldad Eilam by Eldad Eilam could be included in the reverse engineering section.

u/daeken · 2 pointsr/IAmA

Only book I recommend is Reversing by Eldad Eilam (affiliate link if you feel like it: http://www.amazon.com/gp/product/0764574817/ref=as_li_ss_tl?ie=UTF8&amp;amp;camp=1789&amp;amp;creative=390957&amp;amp;creativeASIN=0764574817&amp;amp;linkCode=as2&amp;amp;tag=iha0a-20 )

Otherwise, I just recommend diving in and asking questions of everyone you possibly can. Feel free to contact me, should you want to do so.

u/Grazfather · 2 pointsr/ReverseEngineering

Hah. Just got my order of "Reversing: Secrets of Reverse Engineering" in recently. I'll have to finish that, first.

u/danimoth2 · 2 pointsr/learnprogramming

Thanks for the quick and concise reply. Yup honestly I'm not that impressed with my teachers and I always come on to r/learnprogramming to really learn programming. I've really learned a ton here. As much as I would prefer to just study at home instead of going to school in my country a degree is a must if you want to land a good programming job here or abroad.

If it's not too much do you have any recommended books? I'm looking at this one.

u/rcinsf · 2 pointsr/programming

I agree somewhat but for a true noob, a good starter reference/book is a good thing. K&amp;R is short too. Look at this for comparison.

If you don't have a base for programming it's hard sometimes to know what options are even available to you.

I'm an intermediate programmer and it's likely the best I'll ever be. I work hard as hell keeping up with technology. People keep moving my damn cheese!

My first C book was Teach Yourself C in 21 days. Some ancient version from like 1993-4. It was a good starting point. The key is to just start.

u/theorish · 2 pointsr/csharp

"Pro C# 2010 And The .NET 4.0 Platform" by Troelsen.
£27.23 on amazon.
http://www.amazon.co.uk/Pro-2010-NET-4-0-Platform/dp/1430225491

Very thorough, in-depth, aimed at experienced programmers.
Covers C# and .NET, including CLI, CLR, and an overview of .NET libraries.

u/jhartwell · 2 pointsr/learnprogramming

You need to pick up Pro C# 2010 And The .NET 4 Platform. Not only does it tell you how to use a database, it shows you the 3 options that are available (options as in methods).

u/generalT · 2 pointsr/IWantToLearn

i learned C# in 2008 by starting with 2008 version of this book.

u/messycan · 2 pointsr/programming

Pro C# 2010 and the .NET 4 Platform, Fifth Edition

e: I would also like to say that MSDN is a great place to look: MSDN.

u/ivosaurus · 2 pointsr/PHP

http://www.youtube.com/watch?v=iCUV3iv9xOs&amp;amp;feature=list_related&amp;amp;playnext=1&amp;amp;list=SP442FA2C127377F07

Followed by http://www.amazon.com/dp/143022925X/

When you're beginning in PHP, remember that the code that you write at first will be almost surely very insecure in some way or another. Now no-one is perfect at security, but just keep this in the back of your mind while you're learning :)

u/SteelCity905 · 2 pointsr/PHP

PHP Objects, Patterns and Practice - Expert's Voice in Open Source -

I am only on page 65 and I got a good grasped of OOP.


Building PHP Applications with Symfony, CakePHP, and Zend Framework

Another great book. Especially if you havent decided which framework to go with.

u/ihadisr · 2 pointsr/PHP

The book Learning PHP, MySQL, JavaScript, CSS &amp; HTML5 was one of the most useful PHP books I read as a newcomer to PHP. It's very basic but it teaches how you can start using PHP to do useful and interesting things.

After making it though that book, I think PHP Objects, Patterns, and Practice is a really good next step. It will help you learn to design, organize, and write your code to a more professional standard. It will also help you better understand the workings of a PHP framework.

u/pisskidney · 2 pointsr/PHP

read this
then this

Build something you like while reading them.

u/Thatonefreeman · 2 pointsr/PHP

You should read this: http://www.amazon.com/Objects-Patterns-Practice-Experts-Source/dp/143022925X

This helped me a lot when getting used to OOP and how to practically use it in my apps.

u/ericswc · 2 pointsr/learnprogramming

The ASP.NET website has quite a bit of materials.

For books, I'm a fan of this one

u/delphi_edict · 2 pointsr/csharp

There are two good texts that I'd recommend, each have their own bright spots. Pro MVC 5 and Professional Asp.net MVC 5.

u/Insomn · 2 pointsr/dotnet

Think I solved this one on my own (well, actually started using Pro ASP MVC 5 that I bought last week), but wouldn't mind if someone feels like chiming in just to make sure my thinking's right.

The stock OOBE for MVC5, scaffolding controllers w/ EF bindings, is for when you want to get an MVP out ASAP, right? It'll work as is, but there's hella tight coupling between the MVC and EF, very opinionated, and for enterprise-level apps is generally regarded as a terrible idea.

If you want a loose coupling, and just throw everything off to Ninject to resolve you do have to implement the Repository Pattern yourself from the ground up?

u/tescoemployee · 2 pointsr/learnprogramming

There are a lot of brilliant .NET tutorials on PluralSight including it's own Track of 11 videos and more speciality sources (using .net mvc with angular and web api). It's expensive though.

When I started I found that this book really helped a lot.

https://www.amazon.co.uk/Pro-ASP-Net-MVC-Experts-Voice/dp/1430265299/ref=sr_1_1?ie=UTF8&amp;amp;qid=1478025780&amp;amp;sr=8-1&amp;amp;keywords=asp.net+mvc

u/MysteriousEchidna · 2 pointsr/bioinformatics

I would second The Elements of Statistical Learning is a great text but it is not an entry level stats book. Maybe try Discovering Statistics Using R?

u/tidier · 2 pointsr/Python
u/BobBeaney · 2 pointsr/learnpython

Oh, definitely learn the correct Python 3 idioms. You might want to augment your learning resources with the latest edition of The Python Cookbook which has been updated to Python 3. It's not free but well worth the price!

u/vsonicmu · 2 pointsr/programming

If anyone's interested, Dave Beazley's Python Cookbook (Amazon Link ) has a recipe on implementing multiple dispatch via decorators. This is really just an example to illustrate complex decorator use, so I wouldn't recommend it. But it's possible (and clever)

u/phasetwenty · 2 pointsr/programming

I've read about this practice in Rapid Development, used as a motivator. I have no firsthand experience with the practice as it's described in RD but it I expect that it's not as awful as all that.

As described in RD, the manager offers the project to the engineers from the standpoint of a challenge: "here's this thing we want to build, it has [x] requirements, we need it done, who is in?" The manager then must leave it up to the engineers as to whether or not they wish to participate. It stands to reason that this procedure can't be used in all contexts, for example, successful implementation usually results in a loss of management control and progress visibility. The takeaway is offering people a chance to be a part of something interesting is a powerful motivator.

Note: I just reviewed the chapter in RD and it uses The Soul of a New Machine as a reference.

u/wicked · 2 pointsr/programming

I was in a very similar situation, and read many of the books poeir wrote up. However, the one I found the most helpful was Steve McConnell's Rapid Development.

At least make sure you borrow it from your library and read the part about classic mistakes.

u/eagle2120 · 2 pointsr/ITCareerQuestions

There are a ton of different things you can do on the defensive side. The path here is a bit less defined because you can specialize in each of these areas with out ever really touching the other ones. But I think these are the most important skills as a defender, so I’ll break it up into three smaller chunks. For the most part, defender/Blue-team concepts draw from these skills, I’ve setup the courses in order, as some of these skills may feed into other areas.


IR:

u/guifroes · 2 pointsr/learnprogramming

Interesting!

Looks to me that you can "feel" what good code looks like but you're not able to rationalise it enough for you to write it on your own.

Couple of suggestions:

When you see elegant code, ask yourself: why is it elegant? Is it because is simple? Easy to understand? Try to recognise the desired attributes so you can try to reproduce on your code.

Try to write really short classes/methods that have only one responsibility. For more about this, search for Single Responsibility Principle.

How familiar are you with unit testing and TDD? It should help you a lot to write better designed code.

Some other resources:

u/jeremywho · 2 pointsr/csharp

I'd recommend the basics from searching around, maybe checking out a video on youtube. Figure out how to setup a project using MSTest and one using NUnit (maybe XUnit as well). Do a basic TDD Kata (fizz buzz, etc).

Learn about using fakes/mocks/stubs (NSubstitute is good).

C# Specific book, new version out in November:
The Art of Unit Testing: With Examples in .NET

Get the pre-release here if you want:
The Art of Unit Testing: With Examples in .NET

u/cmaart · 2 pointsr/csharp

Can absolutely recommend the The Art of Unit Testing!

u/moarthenfeeling · 2 pointsr/gamedev

Hi, thank you. :)

You should learn C++ using C++ Primer by S. Lippman. (Not to be confused with C++ Primer Plus which was linked here before). Just be sure to learn modern C++, not "C with classes"! Then I recommend reading Effective C++ and Effective Modern C++ by Scott Meyers. Effective Modern C++ has some awesome examples of modern C++, but it also contains pretty hard edge-cases, so be aware of that.

The best way to learn Lua is by this book. It's very well written and I consider it to be not only the best book about Lua, but one of the best programming books ever!

Lua Users wiki is also very useful and contains lots of resources and sample code.

I also recommend checking out SFML Game Development book which is well written and contains some game programming patterns. You'll find it very useful even if you don't use SFML.

Oh, and Game Programming Patterns is a great read too.

___

Now, how much experience should you have with C++ to make games with it? That's a hard question! You should just start learning it and try making some small games with SFML or Corona. You'll see what you have to learn for yourself. :)

u/xPhoenix777 · 2 pointsr/lua

You can use http://www.amazon.com/Programming-Lua-Roberto-Ierusalimschy/dp/859037985X - WELL worth it - and I write software for a living. I am sure you can find a vendor that sells a digital copy.

u/ledat · 2 pointsr/gaming

The Lua users wiki isn't bad. If you're starting from 0 programming knowledge, buy the book.

u/video_descriptionbot · 2 pointsr/CandidOnReddit

SECTION | CONTENT
:--|:--
Title | Lua Tutorial
Description | Get the Cheat Sheet Here : http://goo.gl/0j15W0 Best Lua Book : http://amzn.to/1SUTogK Support me on Patreon : https://www.patreon.com/derekbanas Data Types 3:43 Math 6:58 Conditionals 10:53 Ternary Operator 15:20 Strings 16:35 Looping 19:11 Repeat Until 20:44 User Input 20:56 For 22:00 For In 22:29 Tables 23:41 Functions 28:26 Return Multiple Values 29:25 Variadic Functions 33:13 Closure 34:27 Coroutines 36:46 File I/O 40:10 Modules 43:32 Metatables 45:30 OOP 51:00 Inheritance 55:04
Length | 0:57:25






****

^(I am a bot, this is an auto-generated reply | )^Info ^| ^Feedback ^| ^(Reply STOP to opt out permanently)

u/welshfargo · 2 pointsr/compsci
u/shagieIsMe · 2 pointsr/programming

In college, I probably wouldn't have cared and had it end up as a fluff class (if it got offered at all, academia is notoriously different than the industry). There was far too many other things to learn. As it was I took intro, mips assembly, digital logic, data structures, compilers, operating systems, theory of programming languages (imperative and functional), theory (the regex to Turing machine), AI, and numerical methods - and that filled up all of my CS degree requirements.

In the mean time, I've found a few books that do capture some of this philosophy. Probably the best is Programming Pearls, though there's some in The Mythical Man Month too. (And yes, this time it is something I wrote...) my list of Five books every programmer should read captures some of that.

The post Ruby’s Principle of Too Much Power is a good read about what happens with too much power.

I do suspect much of this comes from our generation and the code philosophy we (or at least I) was brought into back in college. From that W3 link:

&gt; Computer Science in the 1960s to 80s spent a lot of effort making languages which were as powerful as possible.

More powerful languages to hide the complexity more. C++ and Java came into the world with the idea of encapsulation and private variables - OO coming into vogue. Everything was "more power" (and I have Tool Time flashbacks here). It took two or three decades to come to terms with "too much power is not a good thing."

... and yes, this is finding its way to a blog post of my own.

u/jimauthors · 2 pointsr/compsci

Expert C Programming : Read this after reading K&amp;R C book.
Programming Pearls : Excellent Book
Algorithm design manual : Read it after CLRS.

u/JohnKog · 2 pointsr/compsci

A lot of good mentions here. Although they're more programming and engineering than "computer science", I would add Design Patterns by the Gang of Four, and
Programming Pearls by Jon Bentley.

u/winner123 · 2 pointsr/programming

Programming Pearls by Jon Bentley

u/crowseldon · 2 pointsr/argentina

EducacionIT es decente. Mas allá de lo que hagas. Lo mas importante es que practiques e intentes hacer cosas. Lo que lees no sirve si no lo usás.

Te recomiendo muchísimo que aprendas, en cuanto sepas usar mínima-mente las herramientas, como hacer unit tests y que es Test-Driven Development.

Este libro es excelente para entender TDD y está en java

u/attekojo · 2 pointsr/learnprogramming

If you want an excellent whirlwind tour to computer science basics with a language you've probably never heard of, I'd recommend MIT's Structure and Interpretation of Computer Programs course. The video lectures and the course book are available free online. It's pretty tough going but will seriously expand your mind :)

For design stuff I'd recommend reading books about OO testing and refactoring, like this or this.

u/solid7 · 2 pointsr/learnprogramming

In the interest of giving you something to do which differs from what just about everyone else will say... write the following failing unit test and make it pass ;P

import question
import unittest

class ProjectTest(unittest.TestCase):
def testGetQuestion(self):
test_obj = question.Question()
expected = 'What is the sum of all fears?'
self.assertEqual(test_obj.GetQuestion(), expected)

Refactor, rinse, repeat.

A great reference

Another great reference

u/xoxer · 2 pointsr/programming

This pretty much defines the TDD workflow. It's exactly as mr_chromatic describes it.

u/keithb · 2 pointsr/programming

Try Test-Driven Development. In TDD, programming proceeds by accumulating ever larger catalogues of concrete examples. Get hold of Beck's Test Driven Development: by example Get your buddies to set you up with a TDD environment in Ruby and off you go.

u/tieTYT · 2 pointsr/programming

Yes, his book is titled "Test Driven Development: By Example".

u/bobik007 · 2 pointsr/QualityAssurance

Cool :)

I would start with CD book https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912

Having read it you would understand how modern software development look like and you should understand why test automation is crucial these days.

I had once created a post about learning test automation - you can check it here
http://www.awesome-testing.com/2016/08/how-to-start-learning-test-automation.html

Here are two paths I proposed:

Path 1 - GUI Automation with Selenium

  1. Learn basics of programming language first - preferably with Java for Testers book.
  2. Learn basics of Selenium - preferably with Guru99 Selenium course.
  3. Start writing real tests on existing website, for example http://the-internet.herokuapp.com/
  4. Make sure you understand how Maven/Gradle, TestNG/Junit work.

    Path 2 - REST API Automation with Rest-Assured

  5. Learn basics of programming language first - preferably with Java for Testers book
  6. Learn HTTP protocol with HTTP: The definitive guide
  7. Learn about REST API - Microsoft has recently published it's API Guide with useful links
  8. Learn Rest-Assured with Baeldung, Test Detective or some different guide (there is plenty of them)
  9. Write tests against real API. Check my post which you can use as a reference.
  10. Make sure you understand how Maven/Gradle, TestNG/Junit work.

    There are a couple of testing books which are worth reading too. Perhaps this one is the best https://www.amazon.com/Agile-Testing-Practical-Guide-Testers/dp/0321534468

    Just start small with basic checks. You may even use my github project https://github.com/slawekradzyminski/AwesomeTesting

    Hope I hadn't overwhelmed you :D
u/TalosThoren · 2 pointsr/django

A properly implemented deployment cycle should be a press-button operation. Every environment, including production, should be able to be updated (and rolled back if necessary) unattended and automatically.

I highly recommend this book to anyone presently babysitting deployments.

u/ferstandic · 2 pointsr/ADHD

I'm a software developer with about 5 years of experience , and I used to have the same sorts of problems where I would over-commit to getting work done and under-deliver. To summarize, I changed to where I only commit to tasks that will take 1-2 days or less at a time, and I make it very very public what I'm working on in order to manage both my and my team's expectations. Here are the gritty details (ymmv of course):


  1. I got my team to start using a ticketing system and explicitly define what we are working on with explicit acceptance criteria for each ticket. That way you know where your finish line is. There other huge benefits to this but its outside of the scope of your personal workflow. This of course takes buy-in from your team, but at the very least start a board on trello with "todo", "in progress", and "done" columns, and try to keep the number of items "in progress" to a minimum, and work on them until their finish. A cardinal sin here is to move something from "in progress" back to "todo". This thing you're setting up is called a kanban board

  2. I break the work I do into 1 or 2 workday 'chunks' on our team board, so I don't lose interest or chase another issue before the work I'm doing gets finished. Keep in mind that some workdays, depending on how heinous your meeting schedule is, a workday may only be 4 (or less :[ ) hours long. An added bonus to this is that its easier to express to your team what you're working on, and after practice chunking up your work, you and they will reasonably be able to expect you to finish 2-3 tasks a week. There are always snags because writing software is hard, but in general smaller tasks will have a smaller amount of variability.

  3. As I'm coding, I practice test-driven development, which has the benefit of chunking up the work into 30 or so minute increments. While I'm making tickets for the work I do, i explicitly define the acceptance criteria on the ticket in the form of tests I'm going to write as I'm coding ( the bdd given-when-then form is useful for this ) , so the flow goes write tests on ticket -&gt; implement (failing) test -&gt; implement code to make test pass -&gt; refactor code (if necessary)

  4. This is a little extreme but I've adopted a practice called 'the pomodoro technique' to keep me focused on performing 30-minute tasks. Basically you set a timer for 30 minutes, work that long, when the time elapses take a 5 minute break. After 5 or so 30-minute intervals, you take a 20-30 minute break. There's more to it, but you can read more here. Again, this is a little extreme and most people don't do things like this. Here is the timer I use at work when its not appropriate to use an actual kitchen timer (the kitchen timer is way more fun though). There's a build for mac and windows, but its open source if you want to build it for something else.


    Side note: in general I limit my work in progress (WIP limit) to one large task and one small task. If there are production issues or something I break my WIP limit by 1 and take on a third task (it has to be an emergency like the site is down and we are losing money), and I make sure that whatever caused the WIP limit to break gets sufficient attention so that it doesn't happen again (usually in the form of a blameless postmortem ) . If someone asks me to work on something that will break the WIP limit by more than one, then I lead them to negotiate with the person who asked me to break it in the first place, because there is not way one person can work on two emergencies at the same time.

    Here's some books I've read that lead me to work like this

u/WanderingKazuma · 2 pointsr/softwaretesting

So the difference between 1 and 2 is basically two different modes of delivery. 2 is the traditional large version changes. You'll see this with Adobe CC products, and other large software projects with larger teams.

1 is what you will see with like Chrome, Firefox, and other projects where you might not be aware that an update was made, but still see bug fixes and new features as you use them. This is the continuous delivery model.

1 will require a lot of automation, and a very good CI/CD platform setup. There are plenty of resources around how to get that setup properly. You can always start with versions, and then move into a CI/CD continuous delivery model when your automated process is more fleshed out.

https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912/ would be the resource for CD.

As for your other question, yes I have been working professionally as a QA team lead and/or Manager for almost 10 years now. My focus is really automation testing, but I have worked with many companies setting up QA and SDLC processes.

u/tabolario · 2 pointsr/rails

Hi and sorry for the late reply! The first thing I'll have to ask is what environment are you deploying into, a manually configured virtual machine/bare-metal machine, Heroku, Ninefold? Each of these environments have different (sometimes vastly different) considerations when it comes to deployment of any application. In general though, here's some things that will apply that will apply to any good deployment process (some of what's below echoes /u/codekitten's reply):

  • Remove ALL credentials from your codebase: I can't stress this enough, and even for a simple project it's a good habit to get into early on. It's been enough of an issue that there are even dedicated tools to help people remove hard-coded credentials from their codebases. A good resource to explain both this, as well as the general concept of storing environment-specific configuration data outside of your codebase is this section of the Twelve-Factor App website. Personally, aside from things like tokens that Rails uses internally like Rails.application.config.secret_key_base, I will always use environment variables coupled with something like dotenv or direnv to also manage the configuration for my local development environment.
  • SSL and HSTS: IMHO there is no (good) excuse nowadays to serve a web application over HTTP. Once again, even for simple projects it's a good habit to get into and a good thing to learn. If you're hosting your application on Heroku, all Heroku application subdomains (i.e. rxsharp.herokuapp.com) will respond to HTTPS, but it's up to you to ensure your user's will always use SSL. Rails has the force_ssl setting to do this automatically for you, which you should have turned on in all of your production and production-like environments, but you should also be using HSTS to ensure that your users always visit your site over SSL (force_ssl performs a permanent redirect to https://rxsharp.herokuapp.com but does not set the HSTS headers). The gem that I use most often to take care of setting these headers for me is secureheaders, which also helps you configure a number of other security headers like Content Security Policy headers.
  • Continuous Integration: Let me expand a bit on /u/codekitten's item for passing tests to say that you should have a system in place that will automatically run all of your tests each time you push to your repository and holds you accountable when things break. Continuous integration is a huge topic that I won't dig too much into here, so I'll just point you two two indispensable books on the subject: Continuous Integration: Improving Software Quality and Reducing Risk, and Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation. Conceptually, you will learn almost everything you need to get started and thensome on the topic from those two books. Once you get your CI configuration in place, you will get in the wonderful habit of always making sure your build passes locally before you push to your repository. A good CI script will:
    • Run static analysis tools like RuboCop and Brakeman
    • Run all of tests
    • Notify you when a build fails and when it gets fixed
  • Automate Everything: One of the most important things to learn about deployment early on is automation. Apart from initiating the deploy (and arguably even initiating the deploy itself), everything about your deployments should be automated to the fullest extent. There are several tools in the Rails world that most people use to accomplish this, most notably Capistrano and Mina. If you are using a platform-as-a-service like Heroku or Ninefold, see the documentation for one of those on how to automate various aspects of your deployment process.
  • Deployment Smoke Testing: In my experience working in the Rails world, it seems that not a lot of people automate their post-deployment verification, even though it's very easy to do! It can be as simple as having a post-deployment hook that uses curl to hit a status page on your site that returns the currently deployed revision, and rollback the deploy if it receives an error. It can also be as complex as running a suite of RSpec examples that utilize something like Serverspec to assert the state of each one of your application servers (obviously this one doesn't work as easily in environments like Heroku). In the end, the important things here is that you automate EVERYTHING when it comes to your deployments.
  • Database Migrations: First of all, don't forget to run them! If you're using something like Capistrano to script your deployments, the command to run a deployment that includes a database migration is cap production deploy:migrations, not cap production deploy. On Heroku, you need to run them manually after you deploy using something like heroku run rake db:migrate. One further topic here that I highly recommend you explore is that of zero-downtime migrations. A great introductory article on these is Rails Migrations with Zero Downtime over at Codeship.

    These things are all general items that belong near the top of any checklist for deployment (Rails or otherwise). Hope this helps!
u/Purplemarauder · 2 pointsr/devops

If you've not got a copy of Continuous Delivery bu Humble and Farley I'd really recommend it. It's chock full of best practices with reasons as to why, what etc.

https://www.amazon.co.uk/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912

Sometimes it's easier to point to something that's published rather than have it seem like it's just your opinion I've found. :)

u/oinkyboinky7 · 2 pointsr/devops

No problem.



1.) Is there any option to avoid Windows cause I didn't really grew on it and Linux is much more familiar to me, I can install powershell as a snap I think but I want avoid Windows as much as possible

&amp;#x200B;

I'm the opposite: grew up on Windows and I avoid Linux haha.

&amp;#x200B;

That said, there certainly is the option to simply ignore Windows (there are a lot of Linux only shops out there), however, I would not recommend avoiding it completely.

&amp;#x200B;

Most IT environments that you will end up in have a mix of Windows and Linux. You will be much more attractive to some employers if you can say that you know Windows basics and are comfortable navigating the platform, rather than saying that you are Linux only.

&amp;#x200B;

To add, a lot of enterprises run Windows only tools (ActiveDirectory, Team Foundation Server, etc.).

In order to interface with these tools, you'll need to know some Windows basics.

&amp;#x200B;

At the end of the day, keep in mind that when looking at an enterprise sized network, the operating systems are just one piece of the puzzle. You'll want to be able to step back, visualize the entire network, and not really care what OS is running on the nodes. You'll want to know about the protocols the servers use to communicate (http(s), smb, ftp, etc), how to automate processes regardless of platform, and some basic security concepts.

&amp;#x200B;

2.) What cloud experience should I pick first, I have small budget of 13 euros for Udemy courses so I can pick only one and I want to do it wisely

&amp;#x200B;

Go with AWS 100%. They are the most popular at the moment and a lot (if not most) of what you learn will transfer to the other providers.

&amp;#x200B;

Try to study for the AWS Solutions Architect certification.

&amp;#x200B;

The practice exams here ( https://www.whizlabs.com/cloud-certification-training-courses/ ) are invaluable since they will explain why certain answers are correct/incorrect.

&amp;#x200B;

3.) Would learning Apache, PostgreDB/mySQL be worth ?

&amp;#x200B;

At the end of the day, Apache is basically a web server and the other are databases.

&amp;#x200B;

For a DevOps role, perhaps look into automating the database component of an application deployment.

&amp;#x200B;

4.) Which should I pick first to learn about concept

&amp;#x200B;

Look into CI\CD pipelines. CI = Continuous Integration and CD = Continuous Deployment.

Basically, these pipelines deploy an application to web servers when developers check in their code.

One has to build them using different tools. Have a read here ( https://semaphoreci.com/blog/cicd-pipeline ).

If that interests you, this is basically the Bible on CI\CD ( https://www.amazon.com/Continuous-Delivery-Deployment-Automation-Addison-Wesley/dp/0321601912 ).

&amp;#x200B;

Any more questions feel free to ask.

u/noman_land · 2 pointsr/javascript

Take a look at the book Effective Javascript. It's a really excellent book that deep dives into specific examples and what to look out for.

Secondly, check out some of the tutorials on nodeschool.io. They get into some really neat and important Javascript things.

Thirdly, write some backend Javascript code in nodejs so you can use the skills you already have but apply them to backend concepts. Heroku has some really nice tutorials that will get you writing server code in just a few minutes. https://devcenter.heroku.com/articles/getting-started-with-nodejs#introduction.

Fourthly, use one or more of the popular frontend frameworks to build a simple Todo app. In fact, if you have the time, build the same Todo app in a few different frameworks, so you get an idea of how they work.

Also, when interviewing, just be honest. Tell them you have a number of years of experience but that you've worked for organizations that preferred quick and dirty over perfect. You can parlay that into a positive by showing how learned to get stuff done quickly without spending too much time on small details.

u/randmaniac · 2 pointsr/programming

I found Effecive JavaScipt [1] to be the better and more up to date resource when I had to dive into javascript about 2 or 3 weeks ago.

[1] http://www.amazon.com/Effective-JavaScript-Specific-Software-Development/dp/0321812182

u/deathbysniper · 2 pointsr/javascript

My coworkers and I have been slowly going through this book for a while now and we've all learned a lot.

u/jackmott · 2 pointsr/compsci

Yeah so more of the kind of work this guy is doing:
https://www.youtube.com/watch?v=uEFrE6cgVNY

and greg wilson has a book that reviews this idea:
http://www.amazon.com/Making-Software-Really-Works-Believe/dp/0596808321

u/rferranti · 2 pointsr/programming

Not an opposite view, but IMHO definitely worth quoting on this matter:

&gt; If more than 20-25% of a component has to be revised, it's better to rewrite it from scratch. (Thomas et al, 1997)

It's Greg Wilson, author of "Making Software: What Really Works, and Why We Believe It"

u/zach2good · 2 pointsr/AskProgramming
u/rlfx · 2 pointsr/androiddev

Pleas read this book. It will help you to write better code without so many lines.

u/aaarrrggh · 2 pointsr/learnprogramming

So a lot of these ideas come from the "clean code" book by Bob Martin: http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

He argues in the book that comments are more harmful than helpful over time. The primary reason for this is because people often dive into code, sometimes vaguely reading the comments or even reading them properly, but then make changes and forget to update the comment, which leads to comments that are misleading. The common phrase we use in work is "comments are lies".

Another argument is that not writing comments forces you to write code a certain way, that through necessity needs to be easier to understand. This is commonly referred to as "self-documenting code".

I actually used to dislike this rule when I first started working at my current place, but now I love it and whenever I see code that has lots of comments I groan a little...

In terms of how you go about writing code that is easier to read - often small refactorings can make a big difference, and often times the place where you'd put a comment is a clue about something you could do to refactor some code. Often this can just be better named variables and function names. Sometimes you may find a block of code that you'd stick a comment around - could you extract this code and give it a function name that explains what it does?

If you work in this way, the code tends to document itself, and over time you find you don't really need comments so much.

u/pi_guy10 · 2 pointsr/sysadmin

Thank you. Working my way through "Clean Code" by Robert Martin (https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_api_HcgKzbF6T27B1)

That book will be next on my list to read.

u/Sawta · 2 pointsr/linux

It can also help immensely to help future you, as well as others, if you create clear, concise variable names as well as stick to a strict set of naming conventions when you are crafting programs that may need to be tweaked months, or years down the line. I'm sure this seems obvious to a coder at your level, but so many people seem to overlook this important fact.

It bothers me greatly when I think back to some of the classes that I was taking in college (only a few years ago), where we were encouraged to use variable names like "x" or "string1".

Edit: If you haven't read it already, I would recommend checking out Clean code by Robert C. Martin; I found it to be a pretty fun read with some accurate, real life examples.

u/kitsune · 2 pointsr/programming

Some books I enjoyed:

The Algorithm Design Manual by Steve S. Skiena, $61.15

Real Time Rendering, 3rd. Edition by Tomas Akenine-Moller, Eric Haines, Natty Hoffman, $71.20

Structure and Interpretation of Computer Programs, by Hal Abelson's, Jerry Sussman and Julie Sussman, Free

Clean Code by Robert C. Martin, $37.85

u/jokul · 2 pointsr/todayilearned

No, I just focus on writing code that you can understand without comments. Comments are redundant, prone to being out of date, difficult to manage when picked up by somebody else, and clutter code. If you can't understand a method in 5 seconds without comments, then you should almost certainly refactor that method. This is an industry standard:

http://en.wikipedia.org/wiki/Self-documenting
http://stackoverflow.com/questions/209015/what-is-self-documenting-code-and-can-it-replace-well-documented-code
http://www.amazon.com/dp/0132350882/?tag=stackoverfl08-20
http://programmers.stackexchange.com/questions/51307/self-documenting-code-vs-commented-code
http://codeutopia.net/blog/2014/12/01/how-to-make-your-code-self-documenting/
https://www.youtube.com/watch?v=QcN_Hmh88mA
http://en.wikipedia.org/wiki/Test-driven_development


Comments cause lots of problems. That's not to say comments are always bad, but heavily commented code is more suitable to small projects where you need a quick throughput rather than large maintainable software projects.

u/FoolMan29 · 2 pointsr/java

This is it correct?

u/rf032 · 2 pointsr/arduino

"Clean Code: A Handbook of Agile Software Craftsmanship" is a good reading to improve ur programming skills to organize ur code and make it more readable.

This book adds more levels to my programming skills!

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

u/ralusek · 2 pointsr/learnprogramming

Okay, so this is a very popular book for mainly OO design prinicples:
http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124

http://eloquentjavascript.net/

Also very popular, though Javascript inherently uses a lot of functional programming that might be confusing if your language of choice doesn't make use of first class functions.

http://www.youtube.com/user/derekbanas?feature=

That guy ^ goes over like every design principle you can imagine.

I've also heard that this is great:
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

u/AromaOfPeat · 2 pointsr/programming

If you check nulls all the time you're doing something wrong. Only when interfacing with third parties (through an API) should you be afraid of nulls. If you null check in your own internal methods, you are in essence saying that you don't trust your future self to use the method correctly. I see that type of coding a lot from programmers who come fresh out of college.

edit 1: If you want to read more about it: https://stackoverflow.com/a/271874

&gt; This to me sounds like a reasonably common problem that junior to intermediate developers tend to face at some point: they either don't know or don't trust the contracts they are participating in and defensively overcheck for nulls. Additionally, when writing their own code, they tend to rely on returning nulls to indicate something thus requiring the caller to check for nulls.

edit 2: Not really a surprise that this was an unpopular opinion with the general reddit demographic being so young. I really recommend just reading the link I provided. It goes into more details about what it means to have a "contract" in programming. Also this one might be of interest. You should not have to double check all of your variables all the time. It will make your code unreadable and unmaintainable. The concept is backed by the leading code developers of the world, you don't need to take my word for it. Robert Martin writer of Clean Code:

Don't Return Nulls
------------------

https://i.imgur.com/0lKknlo.png

Don't Pass Nulls
-----------------------
https://i.imgur.com/RgCNbiN.png

u/KoleCasule1 · 2 pointsr/csharp

This is the third book suggested that was written by Uncle Bob.

Can you maybe explain the Difference between:

Clean Code , Clean Architecture and Clean Coder. All books by Uncle Bob

u/N-Dufva · 2 pointsr/learnprogramming

Automate the Boring Stuff with Python Is also something you might want to look into. It is a little bit easier than "Python the Hard Way" in my opinion but reading both at the same time is completely doable.

Edit (added this after a bit of thinking):

For CS in general there are a couple of answers, the first is sadly to give up on reading coding literature on the kindle. Most books will make the code unreadable. But that doesn't mean that there aren't things to read related to programming. My first suggestion would be The clean Coder.

But if you are willing to remove yourself from the kindle I have two more suggestions.

First "The Art of Computer Programming" is the extreme answer. It consists of several books and I have tried going trough it multiple times without success. But each time I open the any of the books in the series I learn something new. But the books should come with big warning, these are not easy to read.

Second I would go trough the CS50 course on edX.com, simply put it's the best introduction to CS available, and it is can be accessed for free.

u/TheSpoom · 2 pointsr/ExperiencedDevs

The Clean Coder is pretty great as it talks about being a professional developer and all that that entails. Very opinionated though (as all of Uncle Bob's books are). "If you don't do TDD, fuck you" is a fairly accurate paraphrasing of one chapter. Still, I found a lot of value there.

I recently read Rework which is a very quick read, but very dense with information on how Basecamp runs their business and many ideas of things that you should or should not do. If you do any freelancing or are thinking of starting your own business at some point, I'd recommend it.

Probably going to read Remote next as I'm working with remote business partners myself.

u/SpaceIsntReallyCold · 2 pointsr/freelance
u/the_real_chef · 2 pointsr/SoftwareEngineering

Clean Code Books:

u/_nur · 2 pointsr/Futurology

So you think Uncle Bob is a recent CS graduate?

He authored this book

https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073

u/besna · 2 pointsr/programming

That what who8877 wrote and this book are my recommendations for you.

u/blackblack · 2 pointsr/cscareerquestions

Hey mate, I found that the philosophy of stoicism allowed me to really appreciate what I work on (even those crappy legacy systems). Here is a good primer http://www.goodreads.com/book/show/5617966-a-guide-to-the-good-life.

You said that meditation helps, well I think that a good philosophy for your life can build on that.
You have some awesome savings and at least that is something to appreciate!

Edit: Oh there are also some great tips on "workaholism" and the art of saying "no" in the clean coder by uncle bob (https://www.amazon.com/gp/product/0137081073/ref=as_li_tl?ie=UTF8&amp;amp;camp=1789&amp;amp;creative=390957&amp;amp;creativeASIN=0137081073&amp;amp;linkCode=as2&amp;amp;tag=nodogma-20). It is quite a common problem in our industry that we are overworked, but it comes down to our professionalism and standing up for ourselves and making sure that we don't make false promises. The worst thing that could happen to you if you start leaving on the clock and saying no to ridiculous requests is that you get fired and get to take that sabbatical!!

u/binarybabe · 2 pointsr/TwoXChromosomes

I've found that I gained most of my best experience on the job, and that staying at a job where I wasn't learning anything was a huge mistake and detriment to my career.

That said... I don't think I'm a super genius either. I did well in college and my GPA helped with my first few jobs. But I have lots of hobbies outside of work, and rarely spend my time at home thinking about the office. A lot of times companies aren't looking for the super genius type either... if they were they'd have a hard time filling staffing requirements. I think the keys are learning how to interview well, focusing on letting the interviewer know that you're willing and good at learning and having the basics of OOO down to a T. Come off as confident, even if you don't feel it. It never hurts.

As far as books go, here are some of my favorites:


Programming Interviews Exposed


Programming Pearls


Refactoring



I'm mostly a java programmer, so here are three absolutely necessary java books:


Head First Design Patterns


Core Java 1


Core Java 2 - Advanced


u/sgmctabnxjs · 2 pointsr/programming

It's a search algorithm which divides up the solution space using binary search.

See Programming Pearls by Jon Bentley for an interesting investigation of the ubiquity of binary search.

u/patroniton · 2 pointsr/AskProgramming

Before you look into trying to optimize your code, beyond the basics anyway, I think it's more important to learn how to write readable and maintainable code first. Code that is easier to change, maintain, and write, is much much better than code that runs slightly faster.

Two books that are highly recommended for this are Code Complete and Clean Code.

u/shhh-quiet · 2 pointsr/learnprogramming

You mentioned some issues that sound like code cleanliness and structural issues. Getting better at algorithms really comes down to practice and exposure, there's no shortcut to this. But there's no reason to suffer from bad coding practices if there's room to improve.

A few books come to mind, which may seem like they're coming from left field, and may not seem immediately useful to the task of solving algorithm puzzles, but might be useful in the long term for you to learn how to write correct, clean code and reduce uncertainty:

  • Code Complete 2. Some good tips in here regarding code cohesion, and how to write functions and classes cleanly.
  • Clean Code. More on writing functions cleanly, along with design &amp; testing.
  • How to Prove It. This is a great book that delves deeply into logic. Even just the first chapter or two could be incredibly useful to you. It discusses things like DeMorgan's Laws, which show up a lot in programming and electronics. It deconstructs common logical concepts and phrases into boolean algebra and set builder notation (which inspire Python's list comprehensions). The world of math and logic and proof is not completely isolated from the world of programming.

    EDIT: One other thing is to make sure you understand the limitations of how computers represent numbers. The need for this understanding will become clear very quickly on, say, Project Euler problems. Look into bits, values, integers, signed vs unsigned, IEEE754 floating point.

    And one other thing is that it's easy to compare your solutions against some of the best solutions that exist for those problems and think you're doing a bad job when in fact you're doing an alright job if you manage to solve the problems with decent runtimes. Mind your 80/20 rule here. The extra time it probably took those people to craft those solutions is not 0, which includes whatever time they spent over the years becoming an expert at that language, etc.
u/MrKurtHaeusler · 2 pointsr/software_design

Possibly one or both of Bob Martin's books.
Agile Software Development, Principles, Patterns, and Practices (comes as a Java or C# version, but many of the ideas will probably be useful if you are using an OO language) or
Clean Code

u/crack3rtastic · 2 pointsr/PHP
u/threedaysmore · 2 pointsr/ProgrammerHumor

I'll start by saying if you haven't read Clean Code, then it's a great place to see questions like your answered with examples. It gets a little too in the weeds for some people at the end, but the first several chapters are great for explaining how, why, and when to break things up.

What a lot of it comes down to for me (and there are different opinions on what "clean" code looks like or should look like, it's somewhat stylistic) is readability.

No matter what app you're writing, with a little bit of business/domain knowledge I should be able to look at your code without having seen it before and be able to understand what parts of the code are responsible for what logical operations so that if the requirements have changed or a bug was found I should know right where to go.

I made a small example while nomming some lunch (forgive me for typos or obvious errors lol). The example is a Cash Register app that is responsible for totaling the sale amount given a list of items.

___

Here is the orignal code | Here's the refactored Specifically looking at the CalculateTotalSale methods....

So in a small trivial program it's not as easy to see the benefits, but in the refactored version the total sale logic has been broken up into methods. This way, lets say there's a bug in how we're calculating taxes (in a small app like this they're probably wouldn't be, but in an enterprise POS app that's in an international market tax calculation can be a pain) we've made several ways to track down where taxes are being done. We can look at the usages of _taxes to see where it's being modified, and we can look at CalculateTaxes() method since that's where all the tax logic should be. If we find that tax logic is not there, we should either move there, or consider a small change in design to make it flow easier.

Also we've left the CalculateTotalSale method open for extension as well. Noted by the comments, if the business wanted us to write coupon logic we could put it in it's own method and go from there. We've left a pattern for the next person to follow, they'd be able to get into this code and get to work pretty quickly. Patterns do change though, but since we've followed some fairly fundamental designs of class structure it'd be easy for someone to change the pattern if they needed to. They won't have to look all over the code for pieces of logic if we've grouped it well.

All that being said, the first example still works fine and gets the job done, the discussion above is more of engineering vs programming. Just my two cents though! Sorry if I've made any obvious errors or didn't explain this well!

u/RedScud · 2 pointsr/argentina

Jajaja salta a la vista no?

Comentarios igual te los paso... pero que te encuentres un metodo asi de jeta llamado ersteIndexprufung ponele en vez de firstIndexVerification.

Ya vi cosas como var variavel1 , function asdfg

Ya que hablamos de todo esto:
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

u/Ilyketurdles · 2 pointsr/cscareerquestions

It might be. There's the issue of making things work, then the issue of writing clean maintainable code that others can understand. A good engineer needs to be able to do both. For something like Java or C#, check out SOLID principles. There's also a book called Clean Code which might be helpful.

u/futureisathreat · 2 pointsr/cs50

My ultimate goal at the moment is to move into a digital nomad type role doing mobile development, preferably for Android.

So, my invisioned path from here is to buy or download some books on Android development and start learning. I've located what seems like a good source (of sources) for learning about Java/Android here, (taken from here)though I don't know because I haven't the links yet.

What is a good (and free) Java / Android Development courses online? Anyone have an opinion on Google's?

Does this path seem good? Should I be considering Java and Android Development the same thing? Thank you!

u/ScreamingGerman · 2 pointsr/coding
u/CaffinatedSquirrel · 2 pointsr/learnpython

Clean Code: Clean Code

Clean Architecture: Clean Arch

&amp;#x200B;

Just picked these two up myself.. not sure if its what you are looking for, but seem to be very valuable for software design as a whole.

u/jacobisaman · 2 pointsr/learnpython

I would recommend reading a book like Clean Code. It talks about writing high quality and structured code.

u/ynot269 · 2 pointsr/learnprogramming

Python is great for intro, I say keep at it.
Definitely pick up some books or youtube tutorials if you're struggling with certain concepts.

If you're worried about your code being messy, check out pep8 it's basically a formatting guide for python.

And to take it a step further check out [clean code] (https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) its a little thicc, but it does wonders for code readability.

Also recommend once you get the hang of python, check out Java. IMO it exposes a lot of those underlying concepts more so you'll understand some of the underlying mechanisms in what you write.

Note that rarely using comments isn't necessarily a bad thing

take a look at this

get_date_of_birth(person):

#return the date of birth for a given person

get_date(person):

Which one reads better?


You'll learn this if you read Clean Code, but code is for humans. What you write will be read by humans, it gets compiled down / interpreted into machine language for computers but as far as anyone seeing your code it will be humans.

edit: forgot about md formatting

u/hugthemachines · 2 pointsr/AskProgramming

I would recommend reading Clean Code. It is a good, easy-to-read book about how to write quality code. It can help you a bit for all your languages.

Other than that, perhaps you could helpan open source project? Then you get real coding practice.

u/TangerineWaves · 2 pointsr/learnprogramming

I like Clean Code by Robert C. Martin.

u/TartarugaNL · 2 pointsr/learnpython

This great book hammers the point home that, as a programmer, you are an author. So I'd say your education and teaching experience are an excellent starting point. Read the book and be prepared to reason about why you care about code quality. Any potential employer who cares about the future of their business should pick up on this. Be upfront about your (lack of) experience and show that you want to learn. Work on a portfolio of personal projects: noone expects a newbie to have indepth library knowledge, but experience does count.

u/gin_and_toxic · 2 pointsr/webdev

Some highly recommended books:

u/balefrost · 2 pointsr/AskProgramming

Heh, sure.

A lot of people are fans of Code Complete. I tried reading it after being in industry for a decade, and I found it to be very dry and boring. The general consensus from people that I've talked to is that it's more useful when you're just starting out. Maybe I just came to it too late.

A better book (in my opinion) in that same vein is Clean Code. Clean code is shorter, more focused, and has better real-world examples. It feels less "complete" (hue hue) than Code Complete, but to me, that's a strength. As a quick point of comparison: Code Complete devotes 32 pages to the chapter on identifier naming; Clean Code devotes just 14.

I got a lot out of Design Patterns. I seem to recall that the pattern fad was in full swing back when I read this in 2005-ish. I think I had independently discovered some of the patterns already at that point, but this book helped me to codify those ideas and also showed me some new ones. Some of these patterns are now seen as antipatterns (I'm looking at you, Singleton!), and all of the patterns have an object-oriented bias. But there's still something useful in the pattern language, and this book is a reasonably comprehensive start. The book is somewhat dry, and some people report that Head First Design Patterns is a gentler and friendlier introduction. Head First Design Patterns hits the essential patterns, but misses a lot of the less popular ones.

Eventually, you'll need to work in a codebase with some technical debt. Maybe it's debt that somebody else put there, or maybe it's debt that you introduced. Working Effectively with Legacy Code is still my go-to recommendation. It defines technical debt as code that is not under test, it introduces the idea of "seams" that you can use to pry apart code that's too tightly coupled, and it then provides a cookbook of specific scenarios and reasonable approaches.

If you're looking for thought-provoking videos, I recommend anything by Rich Hickey. I don't know if I've watched all of those, but I remember good things about Hammock Driven Development and especially Simple Made Easy.

Get comfortable with a source control system. I didn't use source control in college, since it wasn't needed for any classes, and that was a missed opportunity. The whole world loves Git, so you'll probably want to learn it if you haven't already. But I'll also toss out a recommendation for Mercurial. I haven't used it in years, but I remember finding it to be quite good.

Good luck!

u/slappingpenguins · 2 pointsr/learnprogramming

Buy Clean Code and read it before going to bed, or during lunch hour

u/36_24_36 · 2 pointsr/cscareerquestions

Are you referring to this?

u/jj2parkie · 2 pointsr/manga

Probably. It might take some refractoring, but you would need a SaaS like Parse to handle the cross platform sync. I never tried Parse, but I don't want to since it costs money after a certain quota. I've heard some horror stories of independent developers messing up their Parse and blowing through their quota as they failed to put a kill-switch.

Same. I started this project around November to learn Android development. I have a year off before I start college, so I thought of learning some software development. My only experience at the time was high school computer science using C#, so even if you are learning you can contribute. :) Even if it's intimidating you can contribute by submitting issues and such. I contributed to a small database library which was over my head, but I browsed the source to find out how to do something, found an typo in the SQL, and submitted an issue explaining the problem and how to fix it: he forgot a letter.

Although I started learning programming in 2014, if you need any advice on learning Android development, you can PM me. I can provide a list of books you can find online which are helpful for learning Java:

  • Effective Java

  • Advanced Topics in Java

  • Clean Code

  • Design Patterns


    All these books are sectioned such that you only need to read parts you want to, so they are very good references. These books really helped in knowing the syntax of a language and knowing how to use the language which I found was very important for a project of this scale. My first version of it was so hacked together that it was impossible to refractor to add new features. These books really helped for the second version even though I couldn't apply what the books advised effectively.
u/forthesailsofnight · 2 pointsr/csharp

This book explains fairly well what many professionals consider 'clean code'.

Stay true to OOP and keep in mind the writings of this book, and i think you will avoid most major setbacks.

u/CodeTamarin · 2 pointsr/gamedev

You always want processing. You may or may not need graphics. I saw you say you liked fighting games. You'll need a decent rig with some capable graphics.

You wanna dev?

First, yes you need a machine, a decent one. Do you want to build it? Yes , but if not then check these out. I suggest getting a workstations because they're built for productivity. However, they're expensive.

Also, I'm not sure you should commit to a desktop. Two words: Game Jams. You might want to take part in communities involved in game making games. For inspiration, mentorship and just overall fun. If you're not familiar, games jams are when developer enthusiasts get together and build a game over a period of time. The games tend to be simple and set around a theme for the event.

In which case, look at some cool laptops. The reason I suggest getting a gaming laptop is that it will have the graphic card you need, it doesn't need to be high end, just good enough to not be a toaster. Also gaming laptops tend to be more powerful.

So from a dev point of view, they're pretty solid. Personally, I prefer workstations. If you asked me, I would get a workstation with a video card, but those are very expensive and maybe when you master your craft you can drop some real cash on it. You're new. So don't spend too much, in case the entire thing doesn't jive with you. Worst case you get a decent gaming laptop to play MK at the coffee shop. (Don't laugh, I used to play Street Fighter at a coffee shop, it's a nice vibe!)

Also, I would also check out Meetup.com. Your city or area might have groups dedicated to building games and maybe you can learn with another person. From a professional point of view, there's a lot of value in learning to work with others.

So you got your hardware, now for software.

You will likely want to start building stuff. But you're going to need some baseline stuff.

So, I say go with Unity, long term. However you need to get to a place to understand unity. So... you're going to need to learn some coding. To at LEAST be comfortable with code. I say learn the basic and intermediate stuff first then jump into Unity. If you're feeling bold you could also do the advanced.

You will need only Visual Studio and make sure during the install you ask to include Unity.

Finally, you should read Clean Code. Write good clean code. Future you will thank you.

Now, you gotta be productive.

Set up time to do what you want to do. One or two hour blocks. Commit to them. Log that time. Also, get open office, or some other equivalent and start organizing your workflow. as a develop you need purpose in your tasks. So outline your tasks. Develop you "method" for working. Maybe you like self imposed crunch where you just throw on music and go. Maybe you prefer small bursts of productivity. Whatever it is, figure it out.

Journal your work. Go back and read it occasionally. Take non-digital notes on important stuff you learn. Writing helps with retention. You have two processes you need to flesh out.

  • Your development process. How something gets built, tested and delivered.
  • Your Creative process. How you come up with a game idea and flesh out if it's good.

    You're going to need to get a good sense of how to build a proof of concept. This will help you "feel out" your game's mechanics.

    Over time, you will need to explore more advanced idea in computer science like data structures and design patterns... but for now, focus on getting comfortable with code, debugging. Hell, even make a console app text adventure game. Start there. Then get more complexity. The idea here, is to take your time, be diligent and stick to it. Slow isn't bad, not completing is bad. So take your time and good luck!
u/my_password_is______ · 2 pointsr/learnprogramming

this is a free python book

https://automatetheboringstuff.com/

figure out how to rewrite all the programs to use java

especially chapters 11 through 17

see if you can find an inexpensive version of this book

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

read it, learn it well

u/crookc · 2 pointsr/golang



Have you checked out Robert Martin's 'Clean Code' book and/or videos?

I've found Martin's material to be very helpful in actually identifying the attributes of clean code (and conversely, code smells). His examples are all in Java, which would be good for you, given your Java background. Despite his focus on Java and OOP more broadly, I think the fundamentals of clean code are language agnostic and there is plenty of carry-over to Go. He starts with rules around naming things and moves all the way through higher level design principles.

Fair warning though -- Martin goes totally overboard with props, green screens, theatrics, and astronomy history lessons in his videos. The book is more concise, but I'm a better visual learner, so after reading the book I started going through the videos.

u/jl1159 · 2 pointsr/cscareerquestions

Not sure if it exactly follows this situation, but one of the best books I've read - helped me develop some good habits. Highly recommend.


Clean Code: A Handbook of Agile Software Craftsmanship https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_api_irVJzb23P5CQ3

u/crooks5001 · 2 pointsr/learnjava

It's a book/pdf. It's available for free with a little searching but I am on my phone so I'm just going to throw the amazon link your way so you can at least see what it is, who the author is etc...

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

u/grandslammer · 2 pointsr/csharp

Thanks, but this is one 7.5 hour course and does not seem anywhere near a complete path to being job ready.

I have a Udemy account and would buy Mosh's courses on Udemy if I thought that they would form a concise package when put together. I would supplement this learning with books if necessary - specifically the following:

https://www.amazon.co.uk/dp/0735619670/?coliid=I3G8SYORH393ZR&amp;amp;colid=1IRAIWB2MBRLH&amp;amp;psc=0&amp;amp;ref_=lv_ov_lig_dp_it

https://www.amazon.co.uk/dp/0132350882/?coliid=I1ZCBXMO9SV7S2&amp;amp;colid=1IRAIWB2MBRLH&amp;amp;psc=0&amp;amp;ref_=lv_ov_lig_dp_it

https://www.amazon.co.uk/dp/0984782850/?coliid=I1OZDYM4OMN8N7&amp;amp;colid=1IRAIWB2MBRLH&amp;amp;psc=0&amp;amp;ref_=lv_ov_lig_dp_it

But a course where everything fits together (such as a bootcamp I can't afford) is really what I'm looking for.

u/Yevon · 2 pointsr/neoliberal

I recommend reading Clean Code if you haven't already.


https://www.amazon.com/dp/0132350882/


Otherwise you need to be more specific about the question and how you solved it.

u/Parlay_to_throwaway · 2 pointsr/learnprogramming
u/gsaslis · 2 pointsr/devops

I would recommend the Continuous Delivery book (https://continuousdelivery.com/) as a starting guide for what you need to do on the CI/CD front.

It doesn’t go extensively into testing, which is basically your safety net. The Clean Code book (https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) is a good start here.

On the whole Agile Software Development methodologies front, it’s important to understand some principles behind each framework. I’ve found this book useful on that regard: https://www.amazon.com/Agile-Good-Hype-Bertrand-Meyer/dp/3319051547

I know this might sound overwhelming, but so is what you’re describing... : ))
Reading books is an investment that will pay off on this journey you are setting on.

Good luck!

u/RitchieThai · 2 pointsr/AskReddit

Ah, a fellow craftsman of code.

Have you read Clean Code? That book changed my life, and it interestingly suggests that often, comments aren't actually a good idea. There are exceptions.

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

Consider looking into it.

I haven't actually finished reading it, but I read a good deal of it.

u/ghapereira · 2 pointsr/C_Programming

Most places really do have coding standards. Some will also use standards from other companies as a basis, such as Google. If you want a deeper discussion on that, Clean Code will offer a good one.

u/setasensei · 2 pointsr/learnprogramming
u/rm1618 · 2 pointsr/node

Two ideas: first is on crafting code; the second, on fullstack.

Input from programming legends on practices for writing clean code, including evolving code and code smells as indicators that things are not right in the code.

Clean Code: A Handbook of Agile Software Craftsmanship

This nonsense book gets right into initial decisions, sample application features, and architecture diagrams. Clarity is a good thing (measure twice and cut once). Developing on AWS is awesome and you are entitled to a free account for one year while learning AWS: AWS Free Tier.

Full-Stack JavaScript Development: Develop, Test and Deploy with MongoDB, Express, Angular and Node on AWS

(sp and added info)

u/NoahTheDuke · 2 pointsr/Python

Read Effective Python and Clean Code, in that order.

u/jonathan-fulton · 2 pointsr/SoftwareEngineering

A lot of the tips, including this one, come from Uncle Bob's "Clean Code" book. I recommend picking it up for a much more thorough examination of Clean Code principles. https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

There are times when a 4 line restriction on function length is burdensome, but it tends to be a good guideline. Language also matters. I've found it's harder to adhere to the 4 line restriction in Node than PHP for example just based on typical syntax for the language.

u/negative_epsilon · 2 pointsr/learnprogramming

At first, just code. Your code will suck, but it's okay because you're learning.

Then, once you have a good grasp of programming, read

http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672

And

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

You can probably find them for free online.

u/haywire · 2 pointsr/PHP

Do not comment the hell out of your code. Well written code should be self explanatory. Do not comment what, comment why.

Read this book:

Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)

u/teresko · 2 pointsr/PHP

What you have to realize is that framework is a tool for development. It lets you code pages faster, by already have done the "mindless tasks" (like creating user authentication or routing the requests) and letting you focus on the parts that matter.

But there is a cost - performance. Unless you really suck at writing code, framework will make you application slower, because of all the generalization and "works for everyone" approach.

If you have an existing site, just slapping on a framework will gain you nothing. If you want to rewrite you application from scratch, then framework will let you complete that in less time (if you already know how to use said framework).

If instead you want to expand or optimize the existing functionality, you should focus on refactoring and profiling your existing codebase. If that is the case, here are few books which would help you with it: Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin , Real-World Solutions for Developing High-Quality PHP Frameworks and Applications by Sebastian Bergmann and Refactoring: Improving the Design of Existing Code by Martin Fowler. Said book will not give you clear rules for "how to do this", but instead will explain you the direction in which you should aim.

---

P.S. in my personal opinion , CodeIgniter is one of the worst php frameworks out there, with unreasonably high popularity.

u/Gawwad · 2 pointsr/battlestations

Writing bad code is fine when you're starting out, but being able to write code that you and others can read after it's complete is not an impossible feat for a beginner. To get a start in writing good code, read Clean Code. I would suggest reading it after your (/u/Zeno_Zaros) first semester when you have some idea about programming.

u/oowop · 2 pointsr/learnprogramming

I'm by no means an experienced programmer but one of the books I have queued up to read which is recommended in the sidebar and many threads is Clean Code: A Handbook of Agile Software Craftsmanship

u/renang · 2 pointsr/PHP

From one of my favorites books, Clean Code: A Handbook of Agile Software Craftsmanship:

&gt; Others who see that commented-out code won’t have the courage to delete it. They’ll think it is there for a reason and is too important to delete. So commented-out code gathers like dregs at the bottom of a bad bottle of wine.

u/Pet_Ant · 2 pointsr/programming

Clean Code
Refactoring into Patterns
Both talk a lot about them but do not enumerate them authoratatively.

u/iissqrtneg1 · 2 pointsr/programming

Any day!

If you read Clean Code, the author, Robert Martin, goes so far as to suggest wrapping ALL third-party libraries (See CSharpSharp). This is so, should you choose to switch libraries, you only have to change your wrapper and not every place you called that library throughout your entire application. By the time you've written wrappers around this trivial library, you might as well have written it yourself.

This code is provided with out warranty, as per the GPL. Should the project lose support, or a rouge developer makes a check in, your only choice is to fix it yourself. At that point you might as well rolled your own and open sourced it. (Note: even if you fix the OSS library, if the project creator has abandoned it and you don't have write permissions to it's sourcecontrol, it's like you wrote it yourself.)

EDIT: Spelling and punctuation.

u/SunshineBiology · 2 pointsr/dailyprogrammer

Hey! I'm not a senior or something but I have a tip for you (might sound a bit contradictory to what you've been learning in school/uni). I would try to cut down on the comments.

A lot of your comments are just restating exactly what the code says. For example

//Create an array of four structs - one for each tax band
struct taxBand taxBands[4];

Everything your comment says is already said by the code itself. The comment thus does not add meaningful information and just clutters up the code.

Even worse, you add maintenance problems to it: if you have to change the code in the future (let's say we get a new tax scheme and now there are 5 tax brackets), you have to change the code AND the comment. If you forget this at some point (happens easily), the comment will now even give wrong information about the code.

Generally, try to use comments not to describe code, but to describe your intention or very tricky parts about your code. You can also refer to the Google Code Styleguide if you have further interest. Clean Code also has a good segment about it.

The rest seems fine. As an additional exercise, you should probably try not to hardcode going through the taxbrackets, but try to write it in a more general way. At the state your programm currently is, if new tax brackets were added, you would have to write (copy-paste) additional for-loops as you did in

//If the income is more than the upper limit of band 1, but less than band 2, work out how much income is taxable and multipy it by the band 2 tax rate. Add the result to the tax variable
else if(income &lt; taxBands[1].upperLimit){
tax += (income - taxBands[0].upperLimit) * taxBands[1].rate;
}

You can try to rewrite that section so it does not depend on the total number of tax brackets :)

If you have questions, feel free to ask!

u/AnnoraxD · 2 pointsr/java

Good job! Copying existing game ideas is a perfect way to learn

Some recommended reads I had saved as bookmarks if you want to dig even deeper into game programming:

Game programming patterns

Goes deep into all the different patterns of writing a good game engine. Written by one of the devs at EA. There is a free web-version if you scroll down on first page.

Game mechanic explorer

Lots of small snippets and explanations on common mechanics, like bullet trajectories etc. Only for 2d games but much easier to digest then the patterns-site.

A* introduction

A* is a fun algorithm to implement

Clean code book

This one is a must, a book you might get the most out of when working with other people but if you wanna get thinking in the terms of maintainable code and what will be expected of you at a real workplace, take the advices it gives to heart :)

And a tip for a potential next project:

One of the first games I did was a clone of Bomberman. The graphics can be pretty simple but you get to dig into cool stuff like (simple) AI with pathfinding and you can make a very simple multiplayer game out of it that isn't that lag sensitive

u/async2 · 2 pointsr/Physics

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

Maybe check the clean code handbook. Already the first pages describe what many people do wrong which leads to crappy code. You can also find it on the interwebs.

u/MoreCowbellMofo · 2 pointsr/java

&gt;How valuable is an Oracle cert?

No more than any other online course from a respected institution such as google, say: https://cloud.google.com/training/free-labs/ or one of the online courses available at MIT/Stanford.

&gt;What else should I look into to boost my repertoire?

See if your university has any business partnerships you could do a 2-3 month project for. I worked with one of the university's here in the UK as part of a business/university partnership and that gives the students real world experience and us some free work. Win-win if the project is completed.

Sorry - mostly UK (amazon) links :)

TDD - https://www.amazon.co.uk/Growing-Object-Oriented-Software-Guided-Signature/dp/0321503627/ref=sr_1_1, Video by Trisha Gee whos fairly well known for speaking on this stuff: https://www.youtube.com/watch?v=QDFI19lj4OM (some very handy shortcut keys in the video and a good outline of some of the tools available to you).

Clean Code - https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 (by "Uncle Bob")

Design patterns - https://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1

Learn to use shortcuts in Intelli J to speed up your ability to generate/refactor code: https://www.amazon.co.uk/Getting-started-IntelliJ-Hudson-Assumpção/dp/1849699615/ref=sr_1_1

Also Jetbrains does good newsletters (curated by the same lady that made the video above under TDD) sign up to stay up to date with interesting/relevant blogs/articles/industry news https://www.jetbrains.com/resources/newsletters/

Github - https://www.amazon.co.uk/Version-Control-Git-collaborative-development/dp/1449316387/ref=sr_1_4

Bash Commands - https://nikgrozev.com/2016/05/22/shell-cheatsheet-part-1-common-bash-scripting-tmux/

XP/Scrum/Kanban development process - https://www.agilealliance.org/glossary/xp/ the way we work

Trusted developer blog on various engineering topics https://martinfowler.com/

Interview Prep https://www.hiredintech.com/courses

Hint: the above books are likely to be available at any academic library. If not, request them. you likely only need to read 33-50% of them and you'll be golden. I imagine you can likely get hold of electronic versions of these books as well.

The best thing you can do to prepare yourself is to start practising developing projects... get them up on github. it could be a website, a desktop application/game/tool, a demo of sorting algorithms, a web service... literally anything. Fork others' projects, code a feature request and create a pull request back to the original repository/codebase on github. Just build something rather than nothing. Anyone can do the latter. There's so much more opportunity now that we have github available. Think of any thing you might be interested in working on and someone, somewhere has likely already got a project underway in that area, and you're free to submit a pull request to their repository at the click of a button. This wasn't really possible 10-15 yrs ago.

The simple answer is there's so much to know, you just have to find what your interests/passions are and follow those as much as possible.

No matter how good you are at what you do today, the tools will be different tomorrow and may even depend on the industry you enter: AI, web services, blockchain, computer vision, robotics? The list is long and each one requires you to be highly trained (over many years) before you're considered any good at it.

Just try to learn what you can. Find something that genuinely interests you and study it until you become a trusted authority on the subject, or you find something you're more interested in instead.

If you have any ideas for the type of area you might be interested in put them up here and perhaps someone can point you to a relevant project?

https://en.wikiquote.org/wiki/Howard_H._Aiken "Don't worry about people stealing your ideas. If your ideas are any good, you'll have to ram them down people's throats."

u/bluefisch200 · 2 pointsr/ProgrammerHumor

Please consider reading this 😉

I know you are the sole developer but still...that is just confusing.

u/notThaLochNessMonsta · 2 pointsr/javascript

There are more than 356 people in the programming community. This isn't Mumps.

I agree most of the time that early returns are better. But this isn't proof that "most of the programming community agrees". You realize that there is a substantial amount of developers who believe in only 1 return per function, right? Something that is evangelized in Clean Code.

u/minond · 2 pointsr/webdev

Not really related to mobile development, but he should still really enjoy these if he hasn't read them already:

u/invictus08 · 2 pointsr/flask

First of all, applause for the great start.

Here are some criticisms/suggestions I would like to offer. Keep in mind, I am not assuming your level/experience as a software developer:

  1. Functions with smaller size. You see, most of the functions that you have written is lengthy because of the sql statements. Here comes my second point.

  2. Separate business logic, application code, data storage related stuff etc. Keep things modular. That separation is important because you want things to be maintainable and reusable. Your code should be open for extension, but close for modification. If that does not make sense to you, that's perfectly fine, just start from this

  3. On that note, since you are using flask, might I suggest using flask-sqlalchemy instead of sqlalchemy? You may like it better. I know you have mentioned

    &gt; I force myself to write raw SQL Request to get better with SQL

    while that is commendable, it is not really a good idea to write raw sqls in production code if there are ORM library alternatives available. Remember, it's not always you that is going to read/modify the code. While ORM syntax will be fairly universal, your style of writing SQL may vary starkly from other people - which is what creates confusion and lets errors sneak in. Even if you want to do that, maybe keep the raw sql in separate modules (point 2).

  4. Instead of computing everything and then sending the result along with the page, maybe create api endpoints for specific sections; render page with bare minimum info and from the webpage make multiple calls to update the page sections when required. This way, it will be far more responsive, user will not be waiting for you to finish all the computation and if you detect any change in any section of the page, you can just update that particular section with an appropriate api call, thereby avoiding a whole page reload. Design choices.

  5. PEP8. You don't have to blindly follow every rule - just make sure you understand why those rules are there, and that if you are breaking any, you know that it is absolutely necessary for accomplishing what you want. Again, what you want may not always be what you actually need - so be really careful.

  6. This is something I wish I knew earlier - Design Patterns. Without going into much details, I would recommend reading these books to start with and really understand instead of memorizing:
  7. Documentation is also important. Follow the good practices there. A remarkable reference would be Ken Reitz's Requests library.

    Finally, remember that all these are just suggestions, and you may already know them. You will decide which ones to take and which ones to leave behind based on your situation.

    Again, great job (I also learnt something from this). Just make sure you keep running.
u/iheartthejvm · 2 pointsr/ProgrammerHumor

This book changed the way I did things massively and may help you:

Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin) https://www.amazon.co.uk/dp/0132350882/ref=cm_sw_r_cp_apa_i_lxCwCb8S1W5DZ

u/vinnyvicious · 2 pointsr/gamedev

Have you ever heard of the open/closed principle? Or the single responsibility principle? Or Liskov substitution principle? All three are being violated. It drastically reduces the maintainability and extensibility of your code. I can't swap serializers easily, i can't tweak or extend them without touching that huge class and it's definitely not the responsibility of that class to know how to serialize A, B, C, D, E and the whole alphabet.

I highly recommend some literature on the subject if you're curious about it, it would drastically improve your approach to software architecture:

https://www.amazon.com/dp/0132350882

https://www.amazon.com/dp/0201485672

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

http://cc2e.com/

https://www.amazon.com/dp/0321127420

u/jakeinstein · 2 pointsr/gamedev

Hi here's the link - https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 it has made a huge difference in how I code. If you can get your hands on the video that's even better. They are hilarious.

u/guitarino · 2 pointsr/javascript

I really recommend a book Clean Code by Robert C. Martin. It can really help you understand how to write clean code, which you can use and improve right away.

u/Bolitho · 2 pointsr/csharp

Ok, then I would suggest the following ones:

  • Head First Design Patterns
  • Clean Code

    Besides Books you can also find good artciles on the net about OOP basic principles like SOLID.

    Actually I loved the Design Pattern book for showing me, that the basic principles are really the core of OOP. Of course they rely on the building blocks (Abstraction, Inheritance and Polymorphism), but they show you, how you should use those and make advanatge of them in order to build clean, resuable and maintable software. The latter on of the books focuses more on those principles, which is also nice.
u/my_shiny_new_account · 2 pointsr/learnprogramming

Learn about "characterization tests." Also, read this book.

u/thehouen · 2 pointsr/cscareerquestions

I feel for you OP. I recently inherited a fully functional system already in production that was horribly coded. It is now in very good shape, and with a 92% test coverage. It is possible OP! ;)

Yes definitely create the UML diagrams. When you understand it well enough to create a high-level diagram, you will be much better armed, both for making changes, and for showing outsiders why A and B are important to do, since you have something concrete to go from. I would recommend this UML editor for it.

Next, is the code sufficiently under test?
If not, buy and use the book Working Effectively With Legacy Code by Bob Martin. It helps a lot. First step is getting at least some of it it under test. The book is a big one, but you don't need to read it all to get cracking. It is like a recipe book:

"Let me see, okay, I have eggs, chicken, and a 1000+ lines class calling into an unknown legacy system. Then I should use the coding recipe on page 432, and plenty of garlic. Always use plenty of garlic."

Best of luck OP!

u/njharman · 2 pointsr/programming

This doesn't seem as much of a defense as a lack of knowledge/experience/vision(creativity).

There exists methods (processes) and ways to architect that may be applied to even the most complex domains. There are innumerable papers and books on this subject. "Working Effectively with Legacy Code" (http://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052) is decent start as any.

Btw, OOO, state machine, data-driven code, abstraction layers are the methods I'd be likely to investigate given OP description of 1500 line network function.

P.S. language and tool choice is very important. Some lack the power to easily express anything better than spaghetti.

P.P.S There are actual defenses of "Spaghetti Code" or rather why not to refactor or write crap code in the first place. One is YNGNI, e.g. prototype, time (startup needs to ship early to survive till critical mass when it's all getting thrown out anyways). Like everything the cost/benefit needs to be evaluated.

u/Nitrodist · 2 pointsr/rails

The Working Effectively with Legacy Code book is fantastic for bringing legacy code under test and then being able to refactor from there without breaking functionality.

Around 80-90% of the examples in the book can apply to ruby based projects with the remainder being C/C++ or other language specific problems (header files, being an example).

Just as important as the techniques explained in the book is the philosophy it espouses of bringing the code under test.

u/remy_porter · 2 pointsr/webdev

There are a lot of answers to your question. From the very question you're asking, I already know you aren't doing much unit testing. Unit tests are one of the most powerful forms of documentation you can have, because they document the expected behavior of a module. Code without unit tests is legacy code, and unit tests will help you tame that.

Help. They are not a panacea. And don't let "you should start unit testing" turn into "we should start tracking code coverage metrics". But unit tests can add a lot of value.

For unit tests to add value, you also need to have some sort of automated build process. Most build systems will have an easy-to-enable continuous integration mode. Turn it on. At first, your builds will fail. A lot. Especially as you start adding tests. But over time, those red lights are going to get less and less frequent.

Now, what are you doing about managing changes to the application? What's the workflow for putting things onto the backlog? How do they get prioritized? How do people get assigned work? There's no right answer to any of those questions, but I have one big piece of advice: don't let anyone own a module. If Sallybob was the last person to touch the OrderProcessor, the next time it needs a change, give it to Joebob. Yes, you're going to take a small hit on your cycle time. It's worth it.

u/freebit · 2 pointsr/PHP

I totally don't understand what everyone's issue is. My favorite thing to do is to refactor legacy code and my bible for doing it is Working Effectively with Legacy Code. I get a huge amount of satisfaction from turning a complete mess into something magnificent and the best part is that it can all be done with minimal risk.

u/Octopork · 2 pointsr/dotnet

Been down this road and finally started having it make sense a couple of months ago. Try as i did to be better at testing it always felt like a hassle until i shifted my focus to writing testable code.

With that in mind, aside from covering basics of writing tests:

  • SOLID principles, hopefully you know these already(or of them) but if not, read into them. I found i had to start thinking about them while programming for the ideas to click.
  • Inversion of control and DI, I highly recommend Dependency injection in .Net core. Properly following these ideals makes your code so much easier to test and refactor.
  • You don't need to learn all there is about functional programming immediately but at least understand functional purity, pure functions are fairly painless to test.

    Injecting an interface that does nothing but provide DateTime.Now seemed absurd and overly complex when i first read about it but once all those pieces came together everything finally clicked and i no longer hesitated on writing tests as they were no longer difficult to write.

    I've been meaning to read through Working Effectively with legacy code but from what i have read so far it seems to have a huge focus on making old code testable, perhaps an option if your looking at improving your code base in your current job.
u/LeTexan_ · 2 pointsr/csharp

I'm still a young C# developper, around 3 years of C# for websites and APis for small and big companies, but it's not because your predecessors built an in-house framework that this is the right way to build a system. C# is a great language but it shine thanks to the core orientation of productivity delivered by the .NET framework and ASP.MVC.


Of course if your needs are so specifics that you want a custom framework, don't forget that it will become a HR problem. Talented people rarely want to jail themselves to a company and build a specific set of skills that can't be transferred.


But as I said, I'm young. I do think that we are living on the shoulders of giants and that not everything need to be rebuilt. Some of the coolest techs we've seen these past years around containers and micro-services were actually already implemented in the 70's.

That said, I didn't read this book, so I will read it and predictably learn a lot of things. If you didn't already, I would recommend the following books. They aren't C# specific but will help you in the environment you are describing:

u/poloppoyop · 2 pointsr/programming

No "Working effectively with legacy code". Which could be titled "Pragmatic testing".

The DDD blue book, ok. But you'd be better served with "Implementing Domain-Driven Design" which was written 10 years later and have a lot less focus on the technical implementation of DDD.

Mastering Regular Expression should be there too.

u/majimakjang · 2 pointsr/cscareerquestions

try to apply principles from Working Effectively with Legacy Code as you work through your tasks

u/donquez · 2 pointsr/learnprogramming

In terms of practical, professional skills, here are a few I would recommend:

  • The Pragmatic Programmer - writing non-trivial applications requires discipline and a practical mindset. This book is frequently recommended to new programmers as exposure to how think about and approach software development.
  • Head First Design Patterns - schooling introduces you to OOP, but design patterns really highlight the strengths of object orientation. The Gang of Four book is also recommended, but I feel like the Head First book is more approachable.
  • Working Effectively With Legacy Code - You didn't mention if you're coding professionally, but I think the above two books are applicable to someone who wants to take their work to the next level. If you are looking to work in software development, you're going to encounter a lot of legacy code - code that is poorly designed or hasn't evolved well with the application. This book gives you methods for recognizing and untangling the mess.

    For more tailored recommendations, where do you feel that you're weak? There are plenty of college textbooks that can introduce you to algorithms, but if you have an end-goal in mind, you can really focus your learning. Work on some tougher projects than you're used to, and study open source code that does interesting things.
u/mad0314 · 2 pointsr/learnprogramming

I think it would be a good exercise to learn something new and then go back to your old projects and apply them. For example, learn about testing and go back to your calculator and try to get a good chunk of it under tests (another good resource is Working Effectively with Legacy Code, which covers getting projects under tests when they don't have any). Then learn about CI/CD, which use tests, and make a build pipeline for your calculator. Then read Clean Code, read about architectures and patterns, and see if you can improve your architecture. This is just an example, but any of those could give you good talking points if interviewers ask about your projects.

u/YMK1234 · 2 pointsr/AskProgramming

Idk if there is a name for this, but it is a well-known phenomenon, to the extent that it killed companies (Netscape anyone?). The proper way to replace legacy systems is to refactor and evolve them (eg. by splitting out services from a big monolith one by one), not trying to replace them in one big go.

I was told Working Effectively with Legacy Code is a very good on the matter.

u/bgcatz · 2 pointsr/programming

I've enjoyed Working Effectively With Legacy Code by Michael Feathers.

It is an excellent survey of techniques for breaking up monolithic codebases into independently testable modules. He's a strong advocate of test driven development, which I would argue is rather critical to you successfully redesigning your application.

u/Midas7g · 2 pointsr/cscareerquestions

You can. These are called pinning tests. They're usually done over small parts of the code, like a single function. You pull out a bit of code into a separate function, write tests so every line of the new function is tested, and repeat.

Once the section you want to refactor is pinned down, you can change to your heart's content without fear of introducing regressions.

You should read Working Effectively With Legacy Code by Michael Feathers if you haven't already. It changed the way I approach writing code.

u/Tohnmeister · 2 pointsr/programming

True. I can highly recommend reading Working Effectively with Legacy Code by Michael Feathers.

u/_____dban_____-_ · 2 pointsr/java

You might find Michael Feathers Working Effectively with Legacy Code useful. It demonstrates how to safely migrate towards TDD in legacy projects by building up automated functional tests which allow safe refactoring to more testable code.

u/CoreyWhite · 2 pointsr/programming

Doesn't answer your question . . . but get this book. It sounds like it would help.

u/povilasb · 2 pointsr/cpp

It is normal :) I've read somewhere that 20% of our work time we develop new code and 80% new simply maintain the old code. And after a while it sound like true :)

I've been in a situation like you. I've been assigned to maintain a 0.5 million line c++ code base with no tests and no previous maintainers.

Considering that most of the time you're going to spend maintaining your/someones code base, code refactoring, modernizing practices are very valuable. And right now it seems like you have a chance to learn to do so.

Personally, what really saved me was this book: http://www.amazon.co.uk/Working-Effectively-Legacy-Robert-Martin/dp/0131177052/.
So I believe that working on your project is one of the paths you can become a better software developer :)

u/audaxxx · 2 pointsr/webdev

About the refactoring:
Working Effectively with Legacy Code is a bible for refactoring. The single best thing I read about working with legacy shit I have ever read. It really helps.

Great book. After reading it I even enjoy working with shitty code from time to time!

u/depraved_desires · 2 pointsr/beta

&gt; but from what I remember during my time at the company the frontend was pretty rough. The work needed to get it into a state where you could slot "labs" features in a forward compatible way would have likely been a tremendous re-write on its own

but there's proven methodolgies for dealing with giant balls of mud and untested/undocumented legacy code. (I'm partial to this one

First, make sure you have a reproducible environment. Then right a bunch of tests. A BUUUNCH. It's unglamorous, laborious, hard work, but it's necessary to make sure your changes don't break anything. Then you use a combination of heavy refactoring + abstraction, et voila.

I've fixed legacy software, from a Uber-clone that bought a template from a team in India (no shit, the code has references to "UberForX") and having to replace every part piecemeal over months, to re-writing financial services spaghetti code that was doing over a million a year. The approach never really changes.

u/Ozymandias-X · 2 pointsr/PHP

The book that helped me most coping with legacy applications: Working effectively with legacy code

u/kromem · 2 pointsr/javascript

Read this book.

Then, after reading the whole thing cover to cover, start working on your proposal.

From some of the questions you're asking about jQuery integrating with a framework, it's clear that some more basic concepts of how to isolate legacy code and migrate piece-by-piece would be very helpful.

Also, just a suggestion, but I'd highly recommend doing the new development in TypeScript. It'll compile to play nice with any other code you might need it to, but will offer you some awesome tooling that will help in maintaining your project moving forward.

u/ChamesJucks · 2 pointsr/java

Start with Spring Roo + Clean Code:

u/DestroyerOfWombs · 2 pointsr/learnprogramming

A general rule is that classes should represent one object (as an abstraction, not Object as in class instance), and functions should do one task, and it should be understood from name alone everything that they do. If a class is convoluted, it means you probably have more than one class pigeon-holed into a single class. Break it up into separate classes. Same for functions. If a method is too complicated, it should probably be at least two functions.

It might seem crazy to break up a 5 line function into 2 or 3 2-line functions, but you'll be better for it when you return to your code in a month and have to make sense of it again. Hell, it might help in a hour when you realize that one of the jobs performed in that function needs changed, you won't have to weed through a dozen other functions to find the line that you need to change.

Try giving Clean Code by Robert Martin a read. It is a must read IMO, because the suggestions in it will make you a better programmer overall, not just in one language or methodology.

u/Cilph · 2 pointsr/explainlikeimfive

It is good practice to have variable names with clear naming that accurately describes what they are for. What you're suggesting results in variables with absolutely no name whatsoever. (array[0], array[1], array[2] are hardly descriptive).
Moreover, good programming means dissecting your problem into small easily managed chunks. So small, clear functions or objects. If you have a lot of variables in these, you are doing it wrong.

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

u/ldelossa · 2 pointsr/golang

What about some classics like Uncle Bob talks?

A lot of good design focuses on decoupling and creating components which work together but separately also.

Id first look into language agnostic design principles such as SOLID

https://youtu.be/TMuno5RZNeE
https://youtu.be/zzAdEt3xZ1M (golang)

A good book will help.

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

I still keep a copy of the Gang of Four book at arms reach even tho the popularity is dwindling as OOP is not topic of most convos today. However when dealing with DI and sharable components in Golang, i find myself still falling back to abstract factories patterns. Its a good breathe of knowledge to at least glimpse at the patterns here:
Design Patterns: Elements of Reusable Object-Oriented Software https://www.amazon.com/dp/0201633612/ref=cm_sw_r_cp_api_i_7BzvDbXJC5WS4

Once you get thru these topics, you can start picking up what I consider the "hot" architectures of today:
Microservices, event based systems, domain driven design, event sourcing, and architectures aiding themselves to functional programming.

I really enjoy reading Martin Fowler blog posts: https://martinfowler.com/tags/application%20architecture.html

He covers a lot of these topics.

PS: maybe a niche and a personal favorite of mine but ive learned ALOT by researching the different types of kernel architectures. Nothing really geeks me out like those topic, but not for everyone.

A fabulous free course exists on these topics:
https://www.udacity.com/course/advanced-operating-systems--ud189

u/oliviacode · 1 pointr/programming
u/cronofdoom · 1 pointr/cscareerquestions

I would recommend picking up Working Effectively with Legacy Code. It sounds like you could really use it. It teaches how to get unit tests in, how to start finding places to split up the monolithic jumble into smaller, more testable components, how to add features without breaking stuff, and that is just cracking the surface. it is a highly recommended book in the community and I suggest you pick it up.

If you were in PHP I would recommend a book called Modernizing Legacy Applications in PHP, which was my saving grace when I was in your position. If you can find a book like that for Rails then you are set.

I also want to point out that this is a fantastic opportunity for you. They don’t usually teach these skills in college and they are very important. My first job out of college I was in a very similar position. I had a 250,000 line PHP site that was business critical. I had unrestricted access to its very helpful author, however, he had no idea as to modern software development practices and architecture. No source control, no tests, no rollback procedures no documentation or comments, and the site was the spaghetti monster, but holy cow it worked. Oh don’t even get me started about the crazy database naming conventions, the 5000 line “this takes all night to run because the database table doesn’t have a single index” stored procedure, or the crazy hack jobs of ETL from seven or eight other databases.

I ended up reading a lot of code, writing tests, doing a ton of refactoring, and added some features too. It was very, very painful but I learned a lot. Learning to work with complicated code you don’t understand is a very very important skill you will use for the rest of your career. And you can do it!

One other thing. Please do not openly or privately criticize or blame the previous authors or even the code. It is easy to play the blame game and use that to justify things you were doing. Others might be doing it too. Regardless, it will be seen as immature and unprofessional. There are many ways to indicate places for improvement without tearing down the people and code. Please learn from my mistakes.

I wish you the best and offer any other advice, mentorship, or moral support that you require. Just pm me.

u/carillon · 1 pointr/Python

Working Effectively With Legacy Code is probably the best book currently on how to add tests to an existing system.

Specifically it outlines a number of strategies for getting badly-written code under test so you can begin refactoring with confidence.

If you took an untested (or poorly tested) Django app from GitHub or BitBucket and added some tests that would be a really effective example.

u/alinroc · 1 pointr/cscareerquestions

Change what you can, when you can, without introducing significant additional risk. Lead by example - write code the way you feel it should be written within the confines of the system.

Assuming you're using a VCS that was created in this century, delete dead (commented-out) code in files when you're in them for other purposes.

Do not randomly reformat code (especially tabs to spaces or vice versa) unless doing so will make the file internally consistent.

Do not rename things for the sake of renaming them (especially public .

You may find this book useful.

u/alexanderleon · 1 pointr/learnprogramming

The bootstrap you'll use to run your tests will come together and that part will be easy soon enough. Writing testable code will take longer to grock completely. You will learn how to write [SOLID] (http://en.wikipedia.org/wiki/SOLID_(object-oriented_design) code.

I'd start with the Michael Feathers book.

Stick to it. You will be a far better programmer for the effort.

u/maze-le · 1 pointr/softwaredevelopment

Try to make a sketch: What are the dependencies of each function / class / module. How are they interconnected, what is the scope of each dependency (can they be bundled into a module / class on its own?). I usually make such sketches on paper -- old school.

If you have the sketch, you can start unbundling it by trying to minimize the dependencies of each part to one another. Once that is done, you can either refactor or outright reimplement the code. Depending on how big the mess is, a complete reimplementation can be simpler sometimes (albeit more time consuming).

There are also very good books on that issue:

u/brews · 1 pointr/learnprogramming
u/jocona · 1 pointr/cscareerquestions

I would add Working Effectively with Legacy Code to the list. Each chapter title is a problem (e.g., Chapter 14: Dependencies on Libraries are Killing Me) that the rest of the chapter tries to resolve.

It’s great to read through once and occasionally look back on as a reference book. And by learning how to fix bad code, you learn how to write good code in the first place

u/Omnius · 1 pointr/programming

Write an interface layer then use modern language and tooling against the interface.

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

u/amazingmikeyc · 1 pointr/PHP

Yes. Also, Michael Feather's book is good (I think they both reference eachother as they're both in the agile/tdd clique) https://www.amazon.co.uk/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052

(tldr; write automated tests where you can)

u/roosterruley · 1 pointr/PHP

It sounds like the first problem you have is that the code is not written in a way that is easily separated out. That is unfortunate, but unless you get a magic wand it is something you will have to deal with. It sounds like you have the .git sorted out, but really git is just both a parachute and a deployment tool - your problem is in the code.

Your basic setup sounds good with a development server. What I'd recommend is that you either run the developer server locally on your machine or run it in a virtual machine since you don't always seem to have access to a development server.

  1. Stop making changes and make a list of the problems that you want to address, then figure out which you need to work on first.
  2. Have a consistent development server setup
  3. Refactor complicated code into simpler code - if you are spending too much time trying to figure it out it could be done better. Check Refactoring or Working Effectively with Legacy Code. Make little changes that work and test it. Don't try to fix the entire application at one.
  4. Test what you are changing to be sure you don't break things (PHPUnit is perfect for this).
  5. Define an overall structure that makes sense - it doesn't have to be a perfect MVC separation, but it have to make sense to You.
  6. Use an HTML templating tool (if you are not already).
u/MSpeedAddict · 1 pointr/webdev

Have you read Working Effectively with Legacy Code?

I ask because mundane problems and new solutions do not always go hand in hand. Sometimes, working on the bleeding edge isn't possible; even when it is I've been there correcting Microsoft employees in C#, correcting Google on timezones in Chrome, tooling employees in their own stack, etc. and I don't think that's even what you're looking for. Its more of the same.

I've found grace in truly helping companies refactor, restructure, re-stack and modernize their applications for scale. Be it on mainframe applications or full-stack client-facing web applications, taking something old and completely ripping it out for something new is an art form. It's much easier to try and write your own code, find a problem - hit a wall, search for a solution and copy pasta. It's much harder to understand the problem you're facing, that stems from understanding someone else's code and derive a solution. In the same way it's easier to create something new then fix something old (holding constant creativity).

This is what has led me to the art of architecture, refactoring beyond SOLID and design patterns by the GoF - but in truly coming in to a new company and really understanding their business first then their solutions and the consequences of re-writing all of their applications in a new, automated way.

I'm not your "pixel-perfect" guy. While I see why you focus on the "front-end" being what bores you, I think instead you're bored by cookie-cutter solutions you can even begin to find on StackOverflow. I've traced problems on a mobile web client down to processor implementations. I refer to real problems as greenfield, most likely inaccurately. I find design both consequently and paradoxically crucial and irrelevant to success. You can have the prettiest looking face with no neck, working body and arms or everything working just fine but damn ugly to look at and you'll steer clear. It just might not be what interests you.

It's finding where you fit into the puzzle that matters most - this career is both scientific, relational and calculated as it is the most creative art form on the planet. They say development is one of the most free art-forms one can hope to master. Go figure.

--ramble, ramble, ramble

u/Naut1c · 1 pointr/dayz
u/itsmoppy · 1 pointr/golang

BTW, have you read the Feathers book on legacy code? It's pretty damn good and helped me a lot.

I'm not saying you're a bad developer. What I am saying is that Feathers is a rare genius.

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

(There might be a newer edition)

u/devnull5475 · 1 pointr/programming

This is a good read: Working Effectively with Legacy Code

Basically,

  • Get unit tests in place
  • Get instumentation in place
  • Start refactoring

    P.S. I assume you have already studied Refactoring by Martin Fowler.
u/rakeswell · 1 pointr/programming

Thank you for this -- I will certainly try this out. I can also recommend Michael Feathers' book, Working Effectively with Legacy Code

u/ForeverAlot · 1 pointr/programming

I don't know of any one source that teaches "good testing principles". There are thousands of sources and Sturgeon's law is working against you. A few sources are predominantly good, most have bits (often the same bits) of genuinely good advice in-between chapters of bland, uninsightful repetition, many are appropriations of popular acronyms by closely or distantly related professions (no, you're not "testing" a requirement specification, you're just reviewing it), and some sources are just plain bad.

I had an opportunity to attend Dan North's Testing Faster course and would strongly recommend it. In my case it was more helpful for formalising my own experience than learning concrete new things but other attendees did absolutely "learn new things". He made a point that "TDD" and "BDD" are both inaccurate names and that something like "example-guided development" would have been far more honest; he recommended a book, I think Specification by Example, as a good resource to that end (and noted that that name, too, is technically inaccurate). He also confirmed that Cucumber is a solution looking for a problem.

Test Driven Development: By Example by Kent Beck is a classic, and as far as I can remember, decent. It's maybe a little old now, and it definitely misses some subtle points about maintainability of automated tests in general (or perhaps rather, doesn't really address that).

I've skimmed Code Complete 2. I don't remember it in detail but my overall impression of it was that the sooner it becomes irrelevant the better, because that would signify our profession maturing (if not quite reaching maturity). A lot of its contents would be considered basic by contemporary software development standards and that's a good thing. I don't remember what it says about testing. One thing in a very late chapter (33.8?) stuck with me, though: that seniority has little to do with age and your approach to software development will be formed early on.

Working Effectively with Legacy Code by Michael Feathers is excellent, perhaps the most practically applicable one here.

Sandi Metz is famous in the Ruby community for speaking on this topic and there are recordings on YouTube. From what I've seen her material also mainly addresses beginners but it's fast and easy to consume and her form doesn't bother me the way Martin's does.

One piece of advice I picked up from one of those mostly-mediocre sources had to do with naming in tests, trying to capture the essentials. If you're relying on a particular property of a piece of input to test behaviour, make sure this is evident. Conversely, if any input would satisfy, avoid drawing undue attention:

fn bees_can_fly() {
let some_bee = ...
let bumblebee = ...
let dest = ...

assert fly(some_bee, dest);
assert fly(bumblebee, dest);
}

fn bees_can_pollinate() {
let some_bee = ...
let flower = ...

assert pollinate(some_bee, flower);
}

Testing is about developing confidence. There are many kinds of testing and many things to develop confidence in. For automatic tests it's more about checking (arguably not "testing") that you retain correctness in the face of continuous change. Automatic tests that obstruct that change or compromise your confidence are not helping you and should be rewritten or removed. Reliability of tests is usually more valuable than coverage, for instance.

u/popcultur · 1 pointr/webdev

That looks good. There's a good chance I'll read it (this link worked for me).

u/i_do_floss · 1 pointr/funny

The practice of TDD works best for compiled langauges. But even for compiled languages, the experts on the topic disagree on whether test-first is necessary, or if test-later is ok. I've found that test-later works best for me, just make sure you're writing unit tests before you're testing your code through the UI. Generally I build small classes (150 - 250 lines each), then write all the unit tests for the class after I wrote all the code for the class.

You shouldn't write tests for every function. Your tests should exercise every line of code, and every business rule, but the interface that your tests use against your classes should be the same interface that the rest of your code uses against your classes. Writing tests for every function means that you would need to re-write the tests whenever you refactor, which will cause you to move slower.

I would suggest reading this blog post

It shouldn't be difficult to write unit tests against your code. If you are finding it really confusing and difficult, it may be because your function size is too large, or your design is too complicated. Breaking your design into smaller classes, and smaller functions will make it easier to test your code, but ultimately simplifying the design is where most time and effort is saved. You know the design is good when it's very clear how to easily test it. I've found this book to be a good resource in general.

If you're trying to add tests to existing code which has 0 tests, and wasn't designed for tests, I would expect that to take a long time. There's no way around that. Often I find it better to refactor that code, because it's not usually designed well either.

You save time writing unit tests, because it means that you can spend less time testing through the UI. You can test all your business rules using unit tests. When you test through the UI, you're only checking that everything is connected together properly.

The company I work for is similar to the one you described. When I started here, I went against the grain and built things slowly and carefully. My boss recognized the quality of the work I build and now chooses to put me on critical projects, with the expectation that I will spend 2-3x as long as other developers, but also with the expectation that what I build will work well. I've found that this has caused an improvement in quality of life for me, because I'm not in a rush all the time. The reason it takes me longer than other developers is not because of the unit tests though, it's because I refactor code all the time.

u/TheCellch · 1 pointr/learnprogramming

we worked through some items from Effective Java and Clean Code but that is more of an addition and good to know. The Principles we learned were just worked into the lessons and nothing from books. Here's the list of them so you can take a look at them, Wikipedia should give you more information (I linked them for you). However it is important to not just read them and add a checkmark, some of them really change the way you programm. You can't respect all of them cause some will exlude others. And finally not all are really principles some are more of a guideline.
Start with SOLID:

  1. (SRP) single responsibility principle
  2. (OC-Principle) Open/Close Principle
  3. (LSP) Liskov substitution principle
  4. (ISP) Interface segregation principle
  5. dependency inversion principle
  6. (DRY) don't repeat yourself
  7. (CoI) Composition over inheritance
  8. Effective Java Item 17 Design and document for inheritance or else prohibit it
  9. Loose coupling
  10. Test-driven development
    no real Principles from here on:
  11. differ Information Hiding from encapsulation
  12. Use speaking names for classes, methods and attributes
  13. A lot of little units is better then one big (refering to classes)
  14. Use Interfaces to abstract and decouple

    I just checked my notes and here is what I did not mention so far:
    We of course learned the Encapsulation (public, private, protected none). We learned about Collections ((Java Collection Framework) Map, Set, List and the different implementations). Threading, concurrency, Executor, Queue and Dequeue, MVC, Event/Listener Pattern, Exceptionhandling, Comperator, Hash and Equals, Polymorphism, casting.

    Please not that we are not professionals on all this we just learned the basics more or less.

    Hope this helps
u/TheCluelessDeveloper · 1 pointr/ProgrammerHumor

Eh... documentation should be an overview of the process. Specifics need to be within the code itself. Self-commenting code + coding standards is a real thing.

I would recommend any developer to pick up Clean Code and learn some of the basics on self-commenting code and how to write easy-to-read code.

u/WhenDatWeedIsGone · 1 pointr/IAmA

Is it this one I should buy?

u/eru_melkor · 1 pointr/learnprogramming

Some general advice:

Read this book: clean code. Also, go through oracle's coding standards. The company you will work at might have their own coding standards but they are all pretty much based on oracle's. So try to follow that.

Critics on your code:

  • if you follow oracle's conventions, then your class variables shouldn't start with an underscore. I mean, it is a legal variable naming system, but this is not the convention.

  • The following comment is completely unnecessary. Use comments to describe why you are doing certain things. Don't explain the code. Explain why is it the way it is (if necessary).

    /* If no connections, remove connected CSS class */

    if (this._model.getConnections().size() &amp;lt;= 0) {

    getStyleClass().removeIf(element -&amp;gt; element == &quot;connector_connected&quot;);

    }

  • The following comment should be a doc comment. The comments above a method should be a doc comment

    /* Set GUI behaviour that cannot be defined in CSS. */

    private void setDisplay() {

    .....

  • THe comments before a class variable should also be a doc comment. This is because when you generate java docs (html documentation), the program that creates the docs will read your source code and look for doc comments

    /* Holds connection data for managing non-GUI behaviour. */

    private ConnectorModel _model;


    edit: formatting
u/Venthe · 1 pointr/csharp

If possible, avoid it. C# already provides you with enough clarity

public Variable {get;set;}
private variable;

public SampleMethod(variable){
this.variable=variable;
//...
}

Also, descriptive variables are beautiful. Take look at the Clean Code if you haven't had an occasion.

Of course underscore notation is used (sometimes) as could be seen here: http://stackoverflow.com/questions/450238/to-underscore-or-to-not-to-underscore-that-is-the-question/17937309#17937309

u/AMY_bot · 1 pointr/learnprogramming

For less messy amazon links you can extract the part after "/dp/" in

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

and make it:

https://amzn.com/0132350882

BEEP BOP

Plz send any recommendations via PM

u/sleepybychoice · 1 pointr/learnprogramming

Googleable terms might be "software design" and "software architecture".

A good way to learn about why certain designs work and some don't (work well) is to read case studies of software engineering failures and what design decisions contributed to various problems. Searchable terms for this would be "case study", "retrospective", and "postmortem".

I'd also suggest Clean Code by Uncle Bob.

u/chrome_x · 1 pointr/compsci

First, I don't read books too often. So when I do read, I try to find books that have some form of practical aspect in it. I am currently reading Clean Code (https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) and it has exercises to help me understand the situation and to show me how I could design software in a better way. Not only does this help me understand the problem better, but writing/executing the code and feeling the problem makes me really understand why the particular solution is the best solution.

I do not usually take notes because i won't read them again(sorry I know myself too well). I prefer doing these exercises once in a while and hoping that I would be able to fall back on my intuition when I encounter something similar at my job/class/internship/personal coding time etc.

u/grep65535 · 1 pointr/csharp

For programming and everything involved with it, if you want standards and "how should I do this?" questions answered for you, reference this:

Clean Code: A Handbook of Agile Software Craftsmanship https://www.amazon.com/dp/0132350882/ref=cm_sw_r_cp_apa_i_8.NzDb0XEZ34E

Get yourself a copy, read it twice, then you can show your senior what the standard is.

u/Ran4 · 1 pointr/learnpython
  1. Read pep8 - the official python styleguide and format your code according to it. You can run the flake8 tool on your code to get an error report.
  2. Read the book Clean Code by Robert Cecil Martin. It's a classic, and offers tons of great advise.
u/aztristian · 1 pointr/androiddev

That is a very broad question. To be a good programmer you have to practice (program) a lot and not just the same thing, but various kind of projects and challenges, there are just too many areas to list here and the challenges vary by programming language, operating system to the actual problem domain.

Choose a language or 2 from different paradigms (functional, OOP, structured) and try to solve the same problem in each of them.

You'll also want to spend time doing some reading, some well known books for example:

  • The Pragmatic Programmer
  • Clean Code
  • The Passionate Programmer

    For just the programming aspect you can start trying to solve leet code style questions such as the ones found in Coder Wars or Leet Code

    The following book does a much better job at providing an overview of what you can do as a programmer and the available career paths:

  • The Complete Software Developers Career Guide

    &gt; And second question backend or mobile development(native) in future?

    For this I think you can be a successful professional in either, there are times when you can get away with not needing a "backend" with custom logic and you can just use a data store, but if you ever need to do some centralized processing or computation that requires more resources (memory, CPU) than a typical device can offer there's no escaping the need for backend development. The challenges in the backend are very different to the ones on the frontend (be it native or web based) and the approach is more focused on system design with a bit more traditional Computer Science topics.
u/onetwosex · 1 pointr/datascience

OP, so that you know, you mention uncle Bob's "Clean Code", but your link redirects to the book "Clean Coder". They're both great, but different.

I've ordered the book Practical Statistics for Data Scientists: 50 Essential Concepts. Looks great to brush up the basics of statistics and machine learning. Since I haven't actually read it yet, take my input with a grain of salt.

u/ServerSimulator · 1 pointr/Unity3D

&gt;mostly because you need to be good at a lot of mathemtics, is this true?

This is primarily for algorithms. It's pretty easy to be good at math, the hardest part I find for people who program is that they often don't think "outside the box" in breaking their program down.

I and others recommend programming in C#. You should be able to get off the ground with the following resources:

http://learncs.org/

https://mva.microsoft.com/en-US/training-courses/software-development-fundamentals-8248?l=D9b9nHKy_3404984382

https://mva.microsoft.com/en-US/training-courses/c-fundamentals-for-absolute-beginners-8295?l=bifAqFYy_204984382

http://www.amazon.com/Exam-98-361-Software-Development-Fundamentals/dp/047088911X

This list is for programming in general:

http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?s=books&amp;amp;ie=UTF8&amp;amp;qid=1453520022&amp;amp;sr=1-1&amp;amp;keywords=pragmatic+programmer

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

http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?s=books&amp;amp;ie=UTF8&amp;amp;qid=1453520067&amp;amp;sr=1-1&amp;amp;keywords=gang+of+four

http://www.comp.nus.edu.sg/~stevenha/myteaching/competitive_programming/cp1.pdf

http://visualgo.net/

http://www.sorting-algorithms.com/

http://code.tutsplus.com/tutorials/3-key-software-principles-you-must-understand--net-25161

u/CentralCalBrewer · 1 pointr/IAmA

Shoot - I forgot a question mark in my first comment and it got deleted, so I cut an past and the link didn't come though..

Clean Code

u/kvlt_ov_personality · 1 pointr/sysadmin

Thank you! This is exactly what I was looking for, I appreciate the list of subjects to educate myself on.

As far as well documented, readable code - I ordered this from Amazon and I'm hoping it will help me in those areas: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

u/both-shoes-off · 1 pointr/GiftIdeas

I'm a programmer. This is my most favorite keyboard I've ever bought. It's mechanical, but the "clickity" is perfect, and low travel (it's 69.99... and 59.99 for the one without the number pad). They list a few options, but the one's that I find great have "Kailh Latest Low Profile Blue Switches". Also the back lighting is really nice.

https://www.amazon.com/dp/B074QM6F7X/

I don't know what language he's working with, but this book is excellent too. Many of the examples are centered around java/C#, but most concepts apply across many languages. It motivated me to explore further after reading, and to really polish up on my skill set.

https://www.amazon.com/gp/product/0132350882/

u/nvdnadj92 · 1 pointr/javascript

Just to throw in my two cents here, I learned how to think in terms of "clean code" after watching a set of lectures by Robert C. Martin, AKA uncle Bob. He provides an conceptual framework for how to write "clean code" and is widely accepted as the subject matter expert in the software engineering community.

I highly recommend it -- He goes over things like "how to name variables", "when to split up functions into smaller ones", "how to structure programs", etc. I'm not kidding when I say that those lectures were the most meaningful improvement I have made as an engineer.


He also has a book too!

u/return-zero · 1 pointr/learnprogramming

hey sorry i wasnt able to help you out in time. glad you figured it out and got some constructive feedback. i had a sneaking suspicion it was due to a while loop. i would highly recommending reading the book clean code. it has a whole section on proper variable naming among a bunch of other stuff you would benefit from.

u/theclapp · 1 pointr/programming

Came here to post that. +1

Also, Clean Code.

u/Wh0_The_Fuck_Cares · 1 pointr/Unity3D

You're kidding right? That's 100% personal preference... It doesn't matter how you place the braces as long as you're consistent.

This: The Microsoft C# Style Guide. It's literally garbage unless you work for Microsoft or a company that also follows this style guide to religiously. They're suggestions by Microsoft on how to write clean code. If you want a real break down on what clean code is read Clean Code or The Pragmatic Programmer and you'll learn what things are actually worth worrying about.

u/husky11 · 1 pointr/learnprogramming

This was also a good book for me :)

P.S. PM if you want a pdf version :P

u/IEatBasashi · 1 pointr/funny

People who are downvoting this comment need to read this book. Well thought out variable and function names can replace unnecessary comments in many cases.

u/TheSurrealSoul · 1 pointr/funny

At the last place I worked clean code was just how we opperated. I got scolded if I added an unessisary comment. Asking myself "is this comment need? If so, how do I make my code more readable".

I completely agree there are times and places for additional information but ideally good code is easy to follow.

a basic low level example would be holding a users hand through any decision making process.

if(true)
//that means the value was true

else
//it wasn't true

but maybe I have been brainwashed, anyways I had this book on my desk for a few years now, its a good read and great and even though I can disagree with a few things he says its nice to have that engagement with the author.
www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

u/yankexe · 1 pointr/learnprogramming

This is specific to JavaScript but I guess naming variables are the same across all the programming languages. Here's some insights from Clean Code book extracted for JavaScript.

Clean Code Naming Variables GitHub

u/RedSpikeyThing · 1 pointr/programming

Style. After reading through Clean Code I wish there had been more emphasis on this.

u/XVar · 1 pointr/csharp

&gt; This is especially important if there is a "calling protocol", like "cannot call X before Y".

This is known as Temporal Coupling, and is generally not a desirable design. You should enforce correct usage through your design, not through comments.

Incidentally this is another thing covered in Clean Code by Robert "Uncle Bob" Martin, if you haven't read it then you should, it's probably the most important book any software developer will ever read.

u/ensiferous · 1 pointr/PHP

I can't exactly give a better alternative because on how you refactor code as it is highly variable. There are written multiple books about it^1 which span thousands of pages.

^1 Such as Clean Code and Refactoring

u/sh0rug0ru_ · 1 pointr/java

I would suggest reading these books to get a deep understanding of OOP:

  • Agile Patterns, Princples and Practices in C#
  • Growing Object Oriented Software Guided by Tests
  • Clean Code

    Here's a chapter from the Agile PPP book, Heuristics and Coffee, which gives a great overview on how to think in OOP terms. Keep this in mind: OOP is a way of thinking as much as it is a way of programming. OOP lives in the spaces between objects, in the methods, not necessarily the objects!

    Also, note that OOP is a code organization, which really starts to make sense in larger programs. I would suggest writing some larger programs, such as a contact manager, an email client, a chat application, etc. Larger programs will give you a chance to play with technologies such as databases and client/server networking. More stuff to add to the ol' resume.
u/apieceoffruit · 1 pointr/ProgrammerHumor

Oh god where to begin?

***

Well I Like to think there are level of programming understanding that are relatively tiered.

Tier 1 - How to Code

***
This one is tough as there is no real definitive best answer. My personal primer of choice is

  • Sams Learn Java in 24 hours.

    &gt; Fyi - , that is not "in one day" that is , in 24, 1 hour sessions equating to a hypothetical 4 college lectures a week lasting a month and a half of intensive training. A huge amount of homework is required to accompany that primer.

    so now you can write an app, what next? well. to finish the thought:


    Tier 2 - How to Code...

    so other programmers don't want to hit you over the head for each line in your longest function screaming CYCLOMATIC COMPLEXITYYYY

    **

    Here we talk about how to program
    properly* You want to be looking up Uncle Bob . Head over to

  • www.cleancoders.com

    and check out his video form of his famous book:

  • Clean Code....then buy that book.

    Now you should be writing code that doesn't make other programmers eyes bleed.

    Tier 3 - How to Code..To Solve Problems

    ***
    Here we talk about design patterns. Now, you will bump into a lot of debate over their value but...that is stupid. that is like some people saying all carpentry should be done with a saw and another group saying carpenters should never use a saw. Design patterns are names for recognised ways to solve problems you will hit every day in your programming. They may not always work in your case but at worst they will have you thinking around a problem better.

    For a primer, check out:

  • Head First: Design Patterns

    In fact the entire head first series is great, It is like the For dummies series for programming principles. Great for morons like myself.

    With that read, get the real design pattern book:

  • Elements of Reusable...

    Don't expect to actual understand almost any of this. I read that book cover to cover and it didn't actual click for me till it slapped me in the face when i was in the real world developing business tier applications. Although having read it so many times meant I new which pages to flip to when I was ready.

    Tier 4 - How to Code... For Users

    ***

    This is a whole different kettle of fish. Now you may have written the perfect app to do X with only two buttons, you will find quickly that users are adept at licking the buttons in just the correct order to cause your application to explode. You need to program applications so the cast of jersey shore can use it.

    I am a fan of the blog:

  • Joel on Software.

    Joel (Co-founder of Trello) covers a lot regarding front facing applications and UX that is required reading...even if he a bit cavalier on his approach to testing.

    This is the next part. Testing. You are going to want to Learn about Defensive Programming andTesting. There is a wealth of tutorials over on pluralsight for these.

    Tier 5 - When NOT to Code


    **

    This is a hard step to get to. Realising that copy and pasting code is GREAT!..but for the right reasons. Once you jump over the initial Copy+paste = the greatest thing in the world barrier , most developers grow a level of defiance that borders on the absurd. Preferring to rewrite the wheel instead of using ...the wheel. When you can honestly say you
    could* program it from scratch, it is perfectly okay to use libraries and apis.

    This is where I go to:

  • www.codeproject.com

    and hit up Sacha and others. They show you fairly feature complete and interesting implementations of problems, not just the one or two lines you get from Stack Overflow. Granted this is miles more complicated but it shows not only how to do it, but how to do it right and WHY to do it right. and github of course.

    Tier 6 - Learning From Mistakes

    ***

    Now that you have climbed code mountain and are absorbing the combined knowledge of all the internet geniuses, it is time to see where you went wrong.

    Head over to

  • http://codereview.stackexchange.com/

    and post you functional applications. There a number of people will politely tell you not...how but how to do it better, general improvements in design, logic and reusability. take you through the solid principles and much more. Also..say hello to me if you like :P.

    You don't even have to learn exclusively from your own mistakes.

    check out:

  • www.thedailywtf.com

    and cringe at some examples of real software....and if you don't understand why you should be cringing..learn.

    ***

    Tier 7 - How to think like a programmer


    Now things get a little bit meta. The best way to become a great programmer? don't JUST read programming. Read books like:

  • Zen and the Art of Motorcycle Maintenance

  • Don't Make Me Think

    Read anything and everything, exercise your mind. books on architecture, books on carpentry. any kind of design and problem solving with stretch your understanding of how to climb those brick walls you will hit.

    Read some of the more general programming blogs, like:

  • http://blog.codinghorror.com/

    Read anything and everything.

    Final Thoughts

    ***

    Have fun.

    Check out:

  • www.commitstrip.com
  • www.xkcd.com

    and..well..here.

    I would also say as a personal suggestion, although i left it out of the mandatories up above as it is a bit controversial, I suggest going TDD. Test driven development. It is not for everyone, a hard ethos to get into but in the real world, in business applicable coding...a life saver. Uncle bob is the man for that again.

    Finally I am a fan of Rubber Ducking. Great way to work though problems.

    If you want some final reading, I left them out because everyone and their brother has these (and most of the above) in their top 50 programming book lists so it is a mite redundant:

  • Code Complete
  • The Mythical Man Month
  • The Pragmatic Programmer
  • Refactoring: Improving the Design of Existing Code

    ***
    Enjoy.



u/_RealBear_ · 1 pointr/learnprogramming

I recommend reading book called clean code. Answers you have gotten here seem to help only with this specific task. What you need to get better at is how you think about code in general.

u/Kummo666 · 1 pointr/learnprogramming

One that I'm currently reading and it's pure gold is Clean Code.

http://www.amazon.com/gp/aw/d/0132350882

u/Shen_an_igator · 1 pointr/gamedev

&gt; Planning as much as you can before writing code

To add to that:

  1. Learn UML and how to draw activity diagrams. It takes forever at first but will cut your coding time down drastically + create code that is sensible instead of spaghetti code.

  2. Learn the conventions and symbols of UML. Not all of them are necessary, but the basics download here for free. Doesn't matter how long you worked in the industry, lacking this knowledge is detrimental to yourself, your employer, your project, and other coders that have to figure out your shit.

  3. Learn to cleancode before you tackle bigger projects (if you can't read your code like a book and you use variable names that are vague, your code is a mess) sadly I didn't find a good english source, but this book is the anchorpoint

  4. Learn how to create a game-design document. Fix what you want in your game. Once the document is finished, it's immutable. Until the game is done.

u/punkdgeek · 1 pointr/Python

You should probably be a little more disciplined when writing your code, this book will help with strategies on writing good code: http://amzn.com/0132350882. The author discusses Java, but the same techniques apply to python. Obtaining the mythical 100% code coverage with unit test are a good goal, but writing easy to understand, small functions that are as atomic as possible will let you code your "stream of thought" by segmenting each idea into smaller ones that you can name, keep track of, and test. Don't forget to refactor while you still know what your code means; make it work, make it right, make it readable.

u/fatalfred · 1 pointr/Python

A "." has been left in the URL. fixed link

u/jabbalaci · 1 pointr/Python

Link correctly: http://amzn.com/0132350882. Thanks, anyway.

u/navyjeff · 1 pointr/Python

Take the period off the end of the link. link fixed

u/AceBacker · 1 pointr/javascript

All I care about is clean code. Code that is easy to read and change. If a framework helps you do this fine.

If you haven't heard of Uncle Bob check this out: http://amzn.com/0132350882

Or if you prefer his goofy video's: https://cleancoders.com/category/clean-code

u/recruz · 1 pointr/cscareerquestions

I don't have any for Software Architecture specifically yet. But in regards to skill level as a programmer, definitely have the concepts from this book under your belt: http://www.amazon.com/The-Clean-Coder-Professional-Programmers/dp/0137081073

This level of quality coding should be 2nd nature.

u/bart007345 · 1 pointr/androiddev

Sorry you had to experience that. I suggest you read Clean Coder.

u/robotmayo · 1 pointr/learnjavascript

A year from now you will look at your code and say the exact same thing. One of the best ways is to simply write and read a lot of code. http://www.amazon.com/The-Clean-Coder-Professional-Programmers/dp/0137081073 This is a book a lot of people recommended you may want to give it a look. Here is a breif guide of javascript design patterns http://code.tutsplus.com/tutorials/understanding-design-patterns-in-javascript--net-25930 Another design related link http://addyosmani.com/scalablejs/ I havent gotten the chance to read it myself but the author is very knowledgeable so I have faith its high quality.

My personal favorite way to learn how to structure code is to read tutorials and see how the author designed his program. From there I try to understand why they structured their code that way and compare it to how I would have done it. Lastly, your english is fine. :)

u/TanyIshsar · 1 pointr/cscareerquestions

Hey /u/derplefacelel, you are in a tough spot, and this sounds like a tough situation. I think you dodged a bullet here, though I know it doesn't feel like it right now. I think this because the worst thing you can do is delete the wrong data, and the story you've told, as others have pointed out, is a recipe for 'fuck, the users table is gone'.

I think you'll find that /u/UnregisteredIdiot up at the top comments is pretty much right. This screw up is trivial, and you'll need to get used to the pressure. However your story, both in regards to your boss and yourself, points to many serious issues in your office that contributed to this particular situation.

I think you'll find The Clean Coder an excellent resource in helping you learn to better manage your boss, set reasonable expectations and deal with the pressure that /u/UnregisteredIdiot speaks of. Good luck and keep learning man, you'll find your mojo :)

u/bluelite · 1 pointr/learnprogramming

Programming Pearls was very influential for me. Some of the examples are a bit dated, but the overall messages haven't changed.

u/p100101 · 1 pointr/EDC

I'm upgrading my EDC bag next week to a backpack, and felt that I should share my trusted canvas bag of 10+ years in order to give it a proper send off :(

I love its weathered look, but it simply doesn't fit everything that I need and it's difficult to carry larger items when I'm on my bike.

Canvas Messenger Bag

Blender Bottle

Bern Bike Helmet. Berkeley w/ Visor (not attached)

Anker E7 26800mAh Portable Charger

Ray Ban Aviator Classic

Bose Quiet Comfort 25 Noise Cancelling Headphones

GORUCK Tac Hat (mesh - black)

Rogue Velcro Path

Tech21 Impact Tactical Case - Galaxy s5

Rogue Metal Wallet - Rogue Logo

Leatherman 10 (on keys)

Black Notebook (book notes)

Programming Pearls, Second edition by Jon Bentley

Leather Covered Notebook (work notes)

Brown Notebook (scratch notes)

Precise V5 Pens (blue &amp; black)

u/SantaCruzDad · 1 pointr/C_Programming
u/serious_face · 1 pointr/ReverseEngineering

I'm in a similar position (besides having a nice cert ;), and what I'm going through right now is a combination of Lena's tutorials, and Reversing - Secrets of Reverse Engineering. The book actually seems like a really good "foundation" kind of book, since it spends the first 4 chapters or so going over the basics of compilers, operating systems, memory, etc. As for Lena's tutorials, it's hard for me to say because I've only finished a few, but I've heard good things about them. Good luck.

u/robvas · 1 pointr/linux

You need to know a lot of things to be able to figure that kind of stuff out. Not just low-level programming but details about hardware, tricks the developers used to create the product...

These books might be a good start:

Reversing: Secrets of Reverse Engineering

Gray Hat Python - Since you are familiar with Python right now



u/bestseeker · 1 pointr/ReverseEngineering

I'll tell it like it is. Most colleges don't really teach useful things these days in favor of giving you a broad education and emptying your wallet. You'd probably only have one or two courses on reverse engineering, if that. The best thing to do is probably learn it on your own and take whichever major of those you enjoy more. I recommend checking out this book for software RE. http://www.amazon.com/gp/product/0764574817/ref=as_li_ss_tl?ie=UTF8&amp;amp;camp=1789&amp;amp;creative=390957&amp;amp;creativeASIN=0764574817&amp;amp;linkCode=as2&amp;amp;tag=viewsite-20

u/haxcess · 1 pointr/ccna

I remember this text: http://amzn.com/0123742684

And for the programming side of things:

u/omniuni · 1 pointr/learnprogramming

Lots of good advice here. For a book, I recommend the books by Reto Meier, Professional Android 4 Application Development. Google thought he was good enough to teach their Udacity course, so that's good enough for me. Plus, they're good books anyway.

Speaking of Udacity, you can watch all the lectures for free, which includes a demanding, but ultimately thorough Android development course.

u/bilateralconfusion · 1 pointr/androiddev

Buy and read this book. When you've finished reading it, read it again.
http://www.amazon.com/Professional-Android-Application-Development-Guides/dp/1118102274/

u/trefy · 1 pointr/Android

Sorry for the slow answer, I've been busy.
It is very hard to give a specific answer, it is a very vague question and a very large topic.
A couple of things come to mind though :
-First a rant, sorry but it is necessary. You will (or have) read everywhere that fragmentation makes developing for Android a nightmare. Total bullshit and the landmark of shitty fanboys that declare themselves journalists. You will have to decide for a lower version for your app. If your are only doing it for fun, 4.0 is more than enough. If not 2.2 allows you to score all the market. Target the last version &amp; do your homework, all the tools are here to deliver a good experience to all these versions while using the last improvements (official compatibility library, actionbar sherlock, ...).
-Please don't buy a dozen of books. That's just a waste of money. If you have enough OOP knowledge, you don't even need one. If not, Reto Meier wrote one (http://www.amazon.com/books/dp/1118102274). It is recent enough (it is in the 4+ world) and since he is a developer advocate for Android at Google, you will find way less mistakes than from a random author.
-While we are on the topic, stackoverflow can be helpful BUT 90% of the answers are just plain terrible. If you use this website, always keep this in mind and try to be critical of the answers.
-developer.android.com should always be your first stop. There are introduction classes, and documentation for almost all Android related topics.
-If you want to keep informed about what is happening in the Android dev community (libraries, tools, apps, ...), http://www.youtube.com/user/androiddevelopers has an official youtube page and they even have a weekly video with the news. If you want more, circling the Googlers that work on Android + the biggest members of the open source community might be a good idea.
-Even if you suck at or don't care about design, you should still read the guidelines on the android dev website at least once. Keeping these in mind is really helpful when working on UI related problems.

u/TheePumpkinSpice · 1 pointr/explainlikeimfive

I'm studying up on how to create Android apps at the moment. Would you be more inclined to learning how to develop Android applications or iOS applications? If you're interested in learning to program Android apps, the Android application framework includes native Java libraries and thus conventions so you would be required to get comfortable with the Java programming language. The book I'm currently reading is a Wrox publication titled [Professional Android 4 Application Development](http://www.amazon.com/Professional-Android-4-Application-Development/dp/1118102274/ref=sr_1_1?ie=UTF8&amp;amp;qid=1380856547&amp;amp;sr=8-1&amp;amp;keywords=professional+android+4+application+development
).

As far as iOS applications go, I know that the programming language required is Objective C and I'm certain you would need a Mac to develop it on; although you CAN develop using a Mac virtual operating system, the performance is a huge drag. Good luck!

u/dstaley · 1 pointr/Android

I'd pick up a copy of Learn Java for Android Development. It's great for any level of programming knowledge, and it's specifically focused on Android development. However, this won't make you a great Android developer. After this book, I'd recommend getting Professional Android 4 Application Development. It's written by Reto Meier, the tech lead for the Android Developer Relations team at Google, and is pretty detailed without being overwhelming.

u/lacronicus · 1 pointr/androiddev

http://www.amazon.com/Professional-Android-Application-Development-Guides/dp/1118102274

pick it up for 30 bucks, read it, do the stuff. It'll get you where you need to be for most of the things you'd want to do on android.

u/FunctionPlastic · 1 pointr/AndroidGaming

I recommend Professional Android 4 Development. But why ask a non-dev sub a dev question? You would definitely get a better answer there.

Oh and since the move to Android Studio - you want to follow Google guides on setting up your environment, since the change happened recently and all books are outdated in this respect. So set up a basic environment and start coding - the book is relevant from that point on.

Really gives a great description of how all the different components of the system fit in together - the kernel, drivers, APIs, runtime/VM, etc.

u/unleashmysoul · 1 pointr/androiddev

The developer docs are a great place to learn the 'basic stuff' and terms like 'Bundle'.
I can recommend you this book: http://www.amazon.com/gp/aw/d/1118102274/ref=mp_s_a_1_1?qid=1370377881&amp;amp;sr=8-1&amp;amp;pi=SL75

Written by Reto Meier, a Google Android Advocate in the Android Relationship Team.

u/lasthope106 · 1 pointr/learnprogramming

For a complete beginner I would recommend Murach's C# 2010. It's not as well known as some other books, but I really like their format. The book uses this paired-page concept where the code, diagrams, pictures, etc. are in the right page and the explanation is on the left. Not to mention that they show you how to use the IDE, and give you a brief intro into GUI and DB programming.

For a more complete reference check Pro C# 2010.

u/indrora · 1 pointr/csharp

Three things:

  • Get an IDE that doesn't give you help. SharpDevelop is good for this.

  • Get the book "Pro C# and the .NET framework" from Troelsen: http://www.amazon.com/2010-NET-Platform-Andrew-Troelsen/dp/1430225491

  • Learn from production code and someone else's failures.

    I learned most of what I know today by writing VB apps and having the IDE convert them to C# (I stared with SharpDevelop)

u/emcoffey3 · 1 pointr/csharp

Check out this, this, and this.

There's tons of books on C#. I personally like Introducing Visual C# 2010 from Apress and C# 4.0 in a Nutshell from O'Reilly. The former does a nice job covering both the C# language and the most important parts of the .NET framework, then gives a brief intro on the different UI options available. The latter skips the UI stuff, but covers some advanced topics a bit more in-depth. A lot of people seem to like Apress's Pro C#, but I didn't care for it. Also, check out the tutorials on BlackWasp.

After covering all of that stuff, figure out what you want to do and go from there. For Windows development, learn Win Forms and WPF. For web development, look into Web Forms, MVC, and Silverlight. For web services, learn WCF. Then take on a project or two, read articles, etc.

u/borgidiom · 1 pointr/learnprogramming

If you are happy to fork out the cash then this is a good read

http://www.amazon.com/2010-NET-Platform-Andrew-Troelsen/dp/1430225491

Has a great range of topics from C# to WPF to ASP.NET.

u/Spektr44 · 1 pointr/webdev

Years ago, when I wanted to go from hacking around in PHP to learning to use the language properly, I found an excellent book that helped a lot: PHP Objects, Patterns and Practice. The author walks you through creating a basic framework of your own. (Personally, I prefer basic things to heavyweight frameworks anyway.) It's a great book, and it seems there was a new edition published in 2010. I would recommend it.

u/growlzor · 1 pointr/PHP

I started with Head First PHP &amp; MySQL when I started years ago. Two books I loved the most though were Beginning PHP and MySQL From Novice to Professional and PHP Solutions Dynamic Web Design Made Easy.

Later this book helped me immensely PHP Objects, Patterns, and Practice.

Ultimately, php.net is your bible and you can learn everything from there alone. Post on forums and ask for help. Try something and stick with it, don't jump around creating dozens of projects but stick with one and expand it.

Also this

u/fewpeople · 1 pointr/PHP

PHP Objects, Patterns and Practice (3rd Ed) is a fantastic book which is a little bit more advanced that takes you into the OOP aspect of PHP.

u/baconOclock · 1 pointr/PHPhelp

I have an older edition but it was worth every penny.

http://www.amazon.com/Objects-Patterns-Practice-Experts-Source/dp/143022925X

u/nullrouteinroot · 1 pointr/Romania

Eu sunt în general împotriva tutorialelor, cel puţin pe partea de programare. E greu de urmărit şi nu prea are de-a face cu procesul de învăţare ci mai degrabă cu cel de înmagazinare a unor cunoştinţe.
Cel mai bine ar fi la început să începi să citeşti o carte/un articol despre concepte ale programării în general pentru ca apoi să te apuci de sintaxa unui anume limbaj. Plus că îţi trebuie determinare şi multă răbdare.

Odată ce ai prins basicul limbajului, recomandarea mea ar fi să te implici într-un proiect la care poţi contribui cu cod. Codul ăsta va suferi o grămadă de transformări pentru ca la final să nu mai semene deloc cu cel de la început. Ştiu, sună descurajator dar ăsta e procesul natural prin care îţi îmbunătăţeşti skillurile.

Dacă vrei neapărat tutorial video, singura mea recomandarea ar fi PHP with MySQL Essential Training
with Kevin Skoglund
, însă repet: nu mi se pare cea mai fericită metodă de a învăţa programare. Cele mai sfinte lucruri în PHP sunt: cărţile, practica şi http://www.php.net/manual/en/index.php!

Dintre cărţi ţi-aş recomanda:

u/noartist · 1 pointr/PHP

Imo good replacement for gang of four book would be this http://www.amazon.com/Objects-Patterns-Practice-Experts-Source/dp/143022925X
To be honest i don't think there is much depth into PHP itself. If you want to become a better programmer you should pick up other languages preferably fundamentally different from PHP. It will change your preception of problems/solutions and the way you program in your main language.

u/nekochanwork · 1 pointr/learnprogramming

For some definitions:

REST

For a beginner like yourself, you can think of REST as meaning "pretty urls". It means much more than this, in the sense that RESTful urls encodes application state and interactions into the URL, but for your purposes, it is helpful to simplify REST down to "pretty urls". Reddit uses RESTful urls:

  • https://www.reddit.com/r/learnprogramming/comments/4l0qch/super_confused_on_how_to_start_learning_web/

    The non-RESTful (RESTless?) url would look something like:

  • https://www.reddit.com/comments.html?subreddit=learnprogramming&amp;amp;threadId=4l0qch&amp;amp;title=super+confused+on+how+to+start+learning+web

    MVC

    MVC means "model-view-controller", which refers to a specific way in which your application is organized in order to separate your domain layer (model), presentation layer (view), and business logic layer (controller). For a concrete example:

    Model: represents the data elements that you want to show to the user. A model is most often just a vanilla class with get/set properties. Let's imagine I'm building a blog from scratch and I want to show the user a page containing my post: my model logically includes my post (content, date, authors), comments (content, date, authors), etc. My model might look something like this:

    public class BlogPostModel
    {
    public Author[] Authors { get; set; }
    public DateTime CreatedOn { get; set; }
    public string Title { get; set; }
    public string Body { get; set; }
    public string[] Tags { get; set; }
    public Comment[] Comments { get; set; }
    }

    View: a view transforms the model into something your users can see and understand. In web development, a "view" is nearly always the HTML:

    &lt;html&gt;
    &lt;head&gt;&lt;title&gt;@(Model.Title)&lt;/title&gt;&lt;/head&gt;
    &lt;body&gt;
    &lt;h1&gt;@(Model.Title)&lt;/title&gt;
    &lt;div&gt;By @(Model.Authors) on @(Model.CreatedOn.ToString("YYYY-mm-dd"))
    &lt;div&gt;
    @foreach(var tag in Model.Tags)
    {
    &lt;a href="blog/tags/@(tag)"&gt;@(tag)&lt;/a&gt;
    }
    &lt;/div&gt;
    &lt;div&gt;@Model.Content&lt;/title&gt;
    &lt;h2&gt;Comments&lt;/h2&gt;
    @foreach(var comment in Model.Comments)
    {
    &lt;div&gt;. . .&lt;/div&gt;
    }
    &lt;/body&gt;
    &lt;/html&gt;

    Controller: a controller contains your business logic. Typically, this includes logging users in, reading/writing to the database, validating user input on the server side. In ASP.NET MVC, your controller is a class which inherits from System.Web.Mvc.Controller. The controller class can exposes "actions", which are simply methods that return a type of ActionResult. ASP.NET will expose each "action" through a RESTful url called a "route". A simple controller looks like this:

    public class BlogController : Controller
    {
    // url: ~/blog/Article/{articleId}
    public ActionResult Article(int articleId)
    {
    // ...
    }

    // url: ~/blog/AddComment/{articleId}
    public ActionResult AddComment(int articleId, CommentModel model)
    {
    // ...
    }
    }

    ASP.NET

    ASP.NET is a set of classes and libraries built on top of the .NET Framework which helps you build web application. ASP.NET comes in two flavors:

  • ASP.NET WebForms. You can simply ignore this. No one uses WebForms anymore.
  • ASP.NET MVC. Learn this. This is a framework which makes it easy to write RESTful applications in the traditional model-view-controller fashion.

    WebAPI

    WebAPI allows you build RESTful web services that do not have a front-end (that is, calling methods on your API does not return any HTML). This can be occasionally useful.

    .NET

    The .NET framework is a set of libraries developed by Microsoft which helps developers build applications that execute in the Microsoft Common Language Runtime. If use C# on Windows, you already use .NET.

    Mono is alternative, open-source implementation of the .NET framework which runs on Linux.

    jQuery

    jQuery is a Javascript framework which is tailored to selecting and manipulating the DOM on the client side. (The "DOM" refers to the browsers representation of HTML elements on screen; changing an element on the DOM usually has a visible effect to the user in the browser.) It also has some useful utility methods for sending AJAX requests, animating elements on screen, etc.

    Although jQuery is omnipresent in web development, it's not a prerequisite for a beginner to learn. You can pick it up over time as you develop your skills.

    &gt; I understand HTML, CSS, JavaScript, SQL, C# basics. What is the next step?

    Pick up a copy of Pro ASP.NET MVC 5 and start learning.
u/UpNorthMark · 1 pointr/csharp

https://www.amazon.ca/Pro-ASP-NET-Core-MVC-2/dp/148423149X

https://www.amazon.ca/Pro-ASP-NET-MVC-Adam-Freeman/dp/1430265299

Just about to pull the trigger one of these.
I'm not going going be applying for jobs for a couple of years because of college. Should i bother with MVC 5 or try to jump straight into core.

u/roastymctoasty · 1 pointr/learnprogramming

Cool thanks, I'll try those then.

I thought it also might be worth working through this book: http://www.amazon.com/Pro-ASP-NET-Experts-Voice-ASP-Net/dp/1430265299

Have you heard much about it?

u/intangiblemango · 1 pointr/AcademicPsychology

My program requires a number of stats classes and my advisor requires a number more than that. My program also offers a few data science-related specializations, which are, of course, optional, but great.

For some independent learning, Andy Field's Discovering Statistics Using R -- https://www.amazon.com/Discovering-Statistics-Using-Andy-Field/dp/1446200469/ref=sr_1_1?ie=UTF8&amp;amp;qid=1538060236&amp;amp;sr=8-1&amp;amp;keywords=discovering+statistics+using+r -- and datacamp.com are both handy resources.

u/ewiethoff · 1 pointr/learnpython

&gt; Is there any systematic book or tutorial that explains why you do every single thing it has you do?

I recommend the Python Cookbook. The recipes are fine, but really its the combination of code and explanation that's invaluable. So, read the whole book; don't skip the recipes that don't interest you.

u/nagracks · 1 pointr/learnpython

I am Python beginner too and I would say Python Cookbook is a very nice book. You should try it.

u/kurashu89 · 1 pointr/learnpython

If you want a serious book recommendation: Learning Python 5th Edition by Mark Lutz. It's a monster at 1600 pages but to say it's thorough is an understatement. I got the ebook so I can quickly search through it on my phone. Even though I wouldn't consider myself a beginner anymore, I find between this book and the Python Cookbook I find answers to most of my problems (unless they're related to a library).

You can also read Learn Python the Hard Way (my introduction to Python 2). Which is free but not anywhere near the scale of Learning Python. As a warning, there's some coarse language used in it.

If you don't know any Python -- and this will probably stir the pot a little -- learn Python 3. BUT learn how to make it Python 2 compatible. Sure, you'll give up things like advanced tuple unpacking and yield from (to name two off the top of my head) and you'll probably have to use six but when the day comes that you can fully move your library to just Python 3, you'll be thankful.

If you feel comfortable enough with Python to begin approaching a web framework, I would personally recommend Flask. I'm sure quite a few people would disagree and they probably make valid points. But Flask is easy to start with:

from flask import Flask

app = Flask(name)

@app.route('/')
def index():
return "Hello World"

if name == 'main':
app.run()

Miguel Grinberg (you'll see him float around /r/Flask and some of the other Python subs occasionally) has both a great blog series and a great book on building Flask projects. It's not the end all be all of Flask knowledge and honestly, I'd like see more written on working with bigger projects, but given Flask is only 4 years old I'm not surprised.

For Django, I've heard lots of good things about Two Scoops of Django but I've not read it (though, I need to at some point).

I'm unsure about other frameworks like Pyramid or TurboGears or WebPy.

You'll also want to have working knowledge of HTML (not hard), CSS and Javascript (much harder). And getting chummy with libraries like Bootstrap and JQuery/Angular/whatever is probably a good idea, too.

There's also specific concepts you'll want to be familiar with depending on where and what you work on: things like REST, JSON, Ajax, CSRF, etc.

u/KennedyRichard · 1 pointr/learnpython

Python Cookbook 3rd ed., by David Beazley and Brian K. Jones, has a dedicated chapter about metaprogramming. The book is so good the other stuff may also give some insight on metaprogramming or alternatives. I already read it and it gave me insight on my code about metaprogramming and other topics, so it is pretty useful. You can also find a lecture from Beazley about the topic with a quick google search with his name and the "metaprogramming" word.

There's also Fluent Python by Luciano Ramalho, which has three dedicated chapters about metaprogramming. Didn't read the chapters myself but I'm half way into the book and it is awesome, so I'm having great expectations about those chapters.

Don't mind the metaprogramming "chapter count", it is just a piece of information. Quality is what you should be looking for. And I believe those books have it. Even though I admit an entire book about metaprogramming would be neat.

u/DannyckCZ · 1 pointr/Python

Have a look at Python Cookbook, it might just right for you.

u/rocketsocks · 1 pointr/askscience

Code every day. Work on as many little interesting projects as you can. If you don't know any languages I'd suggest starting with Python, there are a million different tutorials and resources online, so getting started shouldn't be a problem.

Add to that, read some books to learn about how software development projects work, different techniques, best practices, pitfalls, etc. Here are my recommendations on books: The Pragmatic Programmer, Refactoring, Code Complete (a bit dated, but still solid), Rapid Development (slightly mis-titled, it's a good overview of different development practices), The Architecture of Open Source Applications, and Design Patterns. Code as much as you can, be ambitious, be analytical and introspective about the problems you run into, and read and understand those books too. There's a lot more you'll need to learn to become a good developer, but what I've described will give you a very strong base to build on.

Oh, and if you don't already know discrete mathematics you'll need to pick that up. I'd recommend this book.

u/Enigma3613 · 1 pointr/programming

Thanks for the recommendation!

What do you think about his books on Rapid Development and Software Estimation?

u/zzygan · 1 pointr/programming

This article is a ripoff of a couple of chapters from Steve McConnell's 1996 book, Rapid Development.

He could have at least given credit to that book for all of the point mentioned. Its not quite word for word, but there are too many similarities to be co-incidental.

u/theqlabs · 1 pointr/REGames

He wrote a book as well, highly recommended: http://smile.amazon.com/dp/1593272898 - one of the only definitive sources for IDA Pro information that isn't scattered about all over the Intardnets.

u/satysin · 1 pointr/learnprogramming

This is a good book. You will obviously need to have some understanding of assembly language for whatever platform you are interested in targeting (I am guessing x86?)

u/Liam2349 · 1 pointr/csharp

Dependency injection and interfaces are mostly more advanced concepts. You can code most things without doing them properly. It comes into the design of your software and testability. It's not something I'd recommend learning first. When it's time, I highly recommend reading The Art of Unit Testing by Roy Osherove: https://www.amazon.co.uk/Art-Unit-Testing-examples/dp/1617290890/ref=sr_1_1?ie=UTF8&amp;amp;qid=1511991453&amp;amp;sr=8-1&amp;amp;keywords=roy+osherove

Until then, you're better off learning how to actually code in C#, and learning important C# features such as the differences between reference and value types, LINQ, asynchronous programming, threading, and more. You can learn all of this with Venkat's C# for beginners series: https://www.youtube.com/playlist?list=PLAC325451207E3105

To develop a web project, you could then move onto Venkat's MVC tutorial series, however if you're planning to store data, I recommend first watching his Entity Framework and SQL Server series.