Coding Blocks

Coding Blocks

By Allen Underwood, Michael Outlaw, Joe ZackBusinessTechnologyEducationHow ToCareers
Download on the App Store

Coding Blocks episodes

  • Back to Basics – Encapsulation for Object Oriented Programming
    It's time to get back to basics. It's easy as a software developer to be working on the latest and greatest frameworks, using the best methodologies, trying out new things. Sometimes it's a good idea to get a refresher on the very basic fundamentals. In this episode we go over the access modifiers that are common in C# and Java as well as ways to emulate these types of behaviors in Javascript. And let's be honest - encapsulation is only effective if you're providing programmers that come after you with a roadmap of how things should work. For that reason we also discuss Command Query Separation and some other ideas and practices that are a part of good programming practices. Be sure to head over to www.CodingBlocks.net/review and leave us a review on your favorite podcasting platform!
    1 hr 8 min
  • Silverlighting through your College Enumeration
    Coding Blocks Episode 22 is live! Organizing your code, moving from school-work to work-work, the future of Silverlight, and lots of poo-pooing! News Great testing tool suggestions from Anders Bauman: TDDHelper, NCrunch We had to look up our new year’s resolutions – not a good sign! Awesome reviews from punforgettable, Jonno Choo, AdamTheHun, Elistaria, JeramyRR, […]
    1 hr 4 min
  • Our Favorite Tools
    We gather around the Festivus pole this holiday season and before we get into the Airing of Grievances, we discuss our favorite tools. No, not people. Actual tools. Srsly.
    1 hr 21 min
  • Our Favorite Tools

    We gather around the Festivus pole this holiday season and before we get into the Airing of Grievances, we discuss our favorite tools. No, not people. Actual tools. Srsly.

    1 hr 21 min
  • We’re Testing Your Patience…
    I figured this title was appropriate considering it's been a month since our last episode.  We've all been incredibly busy so we hope you've been patient waiting and maybe, just maybe it was worth the wait!  We've crammed quite a bit into this episode which is all about testing.  Follow the more link to see the show notes for this particular episode and don't forget to click one of the share buttons there to let all your friends know about the podcast!
    1 hr 27 min
  • We're Testing Your Patience...

    I figured this title was appropriate considering it's been a month since our last episode.  We've all been incredibly busy so we hope you've been patient waiting and maybe, just maybe it was worth the wait!  We've crammed quite a bit into this episode which is all about testing.  Follow the more link to see the show notes for this particular episode and don't forget to click one of the share buttons there to let all your friends know about the podcast!In this episode we're primarily talking about Unit Testing.  While that's the focus of the podcast, we also touch on other types of testing so you'll get a basic understanding of the fundamental differences between the types of tests.  Just keep in mind - the testing we're talking about is writing code to test your code.  It's not someone going through and clicking on items in your UI to make sure they work.  We're talking about code testing code to preemptively find problems before they become big problems.

    Fun Stuff

    It's the holiday season and we would be remiss if we didn't mention our favorite games right now.

    Call of Duty Advanced Warfare

    Call of Duty Advanced Warfare

     

    Middle Earth: Shadow of Mordor

    Middle Earth: Shadow of Mordor
    Vistor Pattern Re-Visited

    @TrentApple and loldot both shared the ExpressionVisitor.
    Click here to see an example of the ExpressionVisitor class

    Mail from You

    Ray wanted to try an anti-SQL database.  Ended up with db4o.  Unfortunately it looks like it may be dead.
    Here's the link to db4o...
    Maybe do a podcast on object to database storage.  Database mappers of various sorts.

    Lewis wants us to create a list of our recommended tools.  Check back here in the future and we'll have a link to the post we create that lists out our favorite developer tools.  Everything from command line replacement tools, comparison tools, text editors, etc.
    Favorite tools of 2014 Coming Soon!

    Marcus wants to hear a podcast on Reactive Extensions.  We may be getting an expert on the show to speak about this stuff....

    Testing

    Testing in general

    • Testing as you go (you running through your app to make sure it works)
    • Automated testing (run from command line, build server, etc.)

      • Several types of testing (not an exhaustive list):

      • Unit testing - testing small pieces of code that have as few dependencies as possible
        • Usually fast running, smaller tests
        • Functional testing - testing how portions of an application work when hooked into its dependencies (databases, web services, etc)
        • UI testing
          • Selenium testing for web applications - fragile? difficult to maintain?
          • Record & Replay / Macro type testing
          • Take longer to run as it's stepping through an app like a user would
          • Regression testing - tests that ensure newer features haven't broken older features that should still function the way they did previously
          • Load testing - making sure a system can continue to function when put under high load
          • Performance testing - making sure your application performs up to some predetermined standard
          • Security testing - ensuring your application is as secure as possible given
            • Unit Testing
            http://en.wikipedia.org/wiki/Unit_testing

            For a single method that you want to test, you may create a dozen test methods to ensure that when you call that one method you always get your expected results.  So, speaking of unit tests, you're typically not writing ONE unit test to test an existing (or new) method, rather you're creating a number of small unit tests to be concise.

            The Triple A Pattern:

            • Arrange - set up your variables
            • Act - call the method under test
            • Assert - did the method do what you expected it to do?

              • Why not just write functional tests as they test higher up?
              http://www.jbrains.ca/permalink/not-just-slow-integration-tests-are-a-vortex-of-doom

              Should the Singleton get blasted some more?!  Michael tries to defend his true love...

              Unit tests should be able to run out of order - this "proves" that you don't have any bad dependencies lying around.

              Testing Pyramid - Michael Cohn
              http://martinfowler.com/bliki/TestPyramid.html
              • GUI Tests
              • Acceptance / Functional Tests
              • Unit Tests
                • Test Driven Development - TDD

                Should you test first?

                Why Test?
                • Fewer errors
                • Catch errors sooner
                • Living documentation?
                • Automatic regression harness
                • Forces looser coupling of code
                • SHORTER FEEDBACK LOOP - you'll find out if there's a problem quickly
                • You can AUTOMATE IT! - run on your box, on a build server, etc.
                  • Javascript testing
                  • Jasmine - behavior driven development framework
                    http://jasmine.github.io/
                  • Karma - testing task runner
                    http://karma-runner.github.io/
                    • Test Runners

                    These find your tests and runs them and tells you what succeeds and what fails, typically looking at classes that have been attributed as test classes.

                    .NET teseting frameworks:

                    • NUnit - One of the most popular for .NET
                      http://www.nunit.org/
                    • MSTest - Bundled with versions of Visual Studio but has some shortcomings -no parameterized tests?!?!
                      http://en.wikipedia.org/wiki/MSTest
                    • XUnit
                      https://github.com/xunit/xunit

                      • Java's primary testing framework is JUnit
                      http://junit.org/

                      Why Does Testing Suck?
                      • It's hard!
                      • I already know it works!
                      • Class / Interface / Code explosion
                      • Dependencies - Injection / Mocking
                      • What's your coverage?
                        • Resources - Links to Other Things We Mention in the Show

                        Huge list of testing resources:
                        http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks

                        Code Complete - excellent guide on complete programming

                        Code Complete

                        Art of Unit Testing - Learn to unit test from the ground up

                        Art of Unit Testing

                        Structuring Your Unit Tests

                        Pluralsight - Test First Development

                        Pluralsight - Test First Development, Part 2

                        DotCover - JetBrains tool for seeing your code's test coverage

                        Tips of the Week

                        Joe found a new podcast he loves - http://www.defensivesecurity.org/

                        Michael loves DotCover from JetBrains - https://www.jetbrains.com/dotcover/

                        Allen has found his new keyboard fling, the Microsoft Sculpt Ergonomic

                        Microsoft Sculpt Ergonomic Keyboard

                         

                        1 hr 27 min
                      • Design Patterns – Iterators, Observers, and Chains, Oh My
                        We’re back to the gang of four, continuing with another segment of design patterns. This time we’re talking about some of our favorite Behavioral Design Patterns: Observer, Chain of Responsibilities, Iterator patterns. Also, why the visitor pattern is weird and what it’s like to be raked over hot coals. News Atlanta Code Camp was amazing […]
                        1 hr 4 min
                      • Design Patterns Part 3

                        We’re back to the gang of four, continuing with another segment of design patterns. This time we’re talking about some of our favorite Behavioral Design Patterns: Observer, Chain of Responsibilities, Iterator patterns. Also, why the visitor pattern is weird and what it’s like to be raked over hot coals.

                        1 hr 4 min

                      About Coding Blocks

                      From the publisher's feed

                      Become the best software developer you can be

                      More shows like Coding Blocks

                      The Daily by The New York Times

                      The Daily

                      111,708 Listeners