Today, on my trip to Minnesota to speak at the user group, I found myself with an Avis reservation but no car. There was a 1-hour wait for cars, even with a reservation. Preferred members were, however, instructed to get their cars at the Preferred desk. Cars were coming in at the same rate that new Preferred members arrived. Therefore, it seems that we plebeians with mere reservations would have to wait a considerable time for a car.
I did wait about 2.5 minutes before pulling out my laptop, tethering my BlackJack II, and getting on the Internet through the AT&T Cellular network. I browsed to Avis.com, signed up as a Preferred member and then promptly walked to the Preferred desk and chose one of the three cars waiting there.
I was then on my way.
MattN sent this great link: Seinfeld loses his reservation: http://www.youtube.com/watch?v=dSZYsyrP3Co
For the folks looking for an answer:
I had something happen today that normally doesn’t happen. I loaded a solution, and Visual Studio just closed. No error message, no dump. It just stopped. Gone. I tried many, many times, and it crashes silently when opening one particular solution. It works fine on every other solution. At first, I thought I’d disable my add-ins, so I disabled:
I even reinstalled PowerCommands because I found someone who had a problem with that. Nothing worked. I finally started thinking about the variables.
The one variable I missed was that this solution had last been worked with before I upgraded to Visual Studio 2008 SP1.
Solution: I deleted the *.suo and *.cache files next to my solution file. I reopened the solution, and everything is fine.
We (Headspring) are starting to offer half-day workshops on various topics where we have expertise. One of the new workshops that has had tremendous registration is the Afternoon of ASP.NET MVC. The next workshop topic that I’m currently planning is a Software Management Workshop.
This workshop would be most appropriate for software managers and leaders. Every organization is different, but through the years, I, and my colleagues, have acquire quite a bit of knowledge surrounding the management of software projects and software organizations. The plan is to start giving some of that knowledge back to the community through free half-day workshops in Austin, TX. We might consider videoing if there is enough interest.
If you have opinions and/or ideas for extra topics, please comment below. This type of workshop would not involve any programming. It is intended to be all about software management and team management.
I then tested out the refactoring and extracted a variable with CTRL+ALT+V. The following dialog was to be expected, and it refactored just like I’m used to with C#.
This is a very interesting IDE, and I’ll be keeping tabs on it. It is focused for Ruby development, but it can be useful apart from a server-side framework.
We have new dates for the Agile Boot Camp part 1 and part 2. If you are interested in raising your agile team’s development to the next level, give us a call.
Below is some of the information about just the part 1 class. And yes, we cover all of it in 3 days. That’s why it’s called a Boot Camp. If these dates don’t work for you, there are more.
Part I Agile Boot Camp™ Topics:
- object oriented programming
- SOLID principles
- design patterns
- dependency injection
- team design on whiteboard
- IDE tools and quickly navigating a codebase
- test driven development
- pair programming
- pain driven development
- domain driven design
- contributing to open source projects
- harnessing the community for extreme growth and continuous learning
- foundations of Agile
You’ve learned the .NET Framework – now learn the principles and tools to use it effectively. This intermediate curriculum will lead developers to work-changing techniques and create momentum towards continuous improvement in an ever-changing field. With a focus on object orientation and software engineering practices refined in real projects, students will discover principles and patterns to manage software complexity. By the end of the course students will have eliminated a reliance on leaky-abstraction APIs by
- understanding software design concepts and principles
- understanding and practicing test-driven development
- practicing working in an effective team
- implementing designs using object oriented techniques and design patterns
- understanding object-relational mapping
- drive future growth through exposure to advanced topics
- lab 1: check out the project and run a unit test
- module: Intro
- module: TDD basics
- lab 2: writing your first failing unit test
- lab 3: writing the code that makes it pass
- demo: working with resharper
object oriented programming
- module: SOLID
- lab 4: interfaces, facade
- lab 5a: strategy pattern
- lab 5b: command pattern
- extra curricular lab: playing with structuremap
team design & advanced tdd
- quick mini-lab involving structuremap
- module: dependency injection / ioc
- lab6: configuring structuremap
- demo: testing with mock objects
- lab7: rhino mocks
- team design on whiteboard
refactoring & pair programming
- lab8: more tests, enumeration base class, specification pattern, .NET 3.5 feature in the code
- module: refactoring
- demo: refactoring legacy code
- lab 9: pair tasks involving refactoring
- extra curricular: student-driven discussion and demo
- lab 10: “refactor this” challenge
- module: DDD basics, terminology
- lab 11: repositories, using provided nhibernate stuff (HSB, DTB, etc.), specification pattern
- module: foundations of Agile
- module: nhibernate
- demo: querying nhibernate
- lab 12: downloading source, creating patch for open source project
- student-driven discussion, demos
This week I enabled Gmail Offline. You have to install Gears, which not seems like Google’s answer to Flash, Java, Silverlight, and the other mini-runtimes that need to leverage the client computer.
When I have a slow (or no) connection, I can flip Gmail into “Flaky Connection Mode”, and I can search my inbox, read, write, and send mail. When I have a connection again, Gmail syncs up just like normal. Very interesting feature. I wonder when I’ll have to start paying for Gmail. I’d be happy to.
Since blogs and podcasts are so searchable these days, I have no doubt that many novice programmers will find the material discounting the SOLID principles and the work of one of the founders of the Agile movement.
By the blog comments on each of these, there are people with strong opinions on both sides. I don’t think it is as black and white as taking sides.
For what it is worth, I, and my company, have found the SOLID principles very beneficial for the quality of the software systems we build. By applying them weighted against experience, systems are easy to maintain and extend.
Lack of experience might cause someone to attempt to apply them in a dogmatic, bureacratic manner. This would fail just as surely as any attempt made by an inexperienced programmer; however, the appropriate application of these principles is a boon to a codebase. I have found that my more senior programmers are able to apply the principles through experience, and those who are still learning the principles can see the concrete applications of them and duplicate them.
The results are very clear and very positive. For instance, on our current, largest project, the codebase continues to be easy to maintain and extend weekly. Even complex business logic is easy to break down, test and verify. New logic can be layered on (extended) without causing lots of churn with existing code (OCP). The application of the SRP causes our code files to be small enough to understand quickly, and interface and method names are very specific, describing the responsibility.
I am not on a crusade to change the entire industry. That takes time, and customers still don’t value success enough to ask the tough questions before hiring programmers. Until the marketplace demands higher quality work, programmers around the world will continue getting paid for shoddy software.
Brendan Enrich has an interesting post on organizing the trunk of the source control for a system. Some of the principles include:
- Having all libraries with the source code
- Having a batch file for the build right at the top
- Sitting down and working immediately with the project.
I like what I see. I think this type of structure should be widely used across many types of .Net solutions.