Slashdot Mirror

This seems to be exactly what svn export [-rREV] url://path is for, since it pulls a static metadata-less (no .svn) copy of that path at that rev. I use it to (re)publish websites with cron, and have used it for bind9 zone files and all sort of other stuff where the .svn files (or their contents) was unwanted.

As to the rather contentious (and mostly fruitless) debate at hand, I'll have at look at what the Pragmatic Programmer have to say about git. They are releasing a new version of their canonical VCS book for it, and their SVN book is what really helped get me going with SVN. http://pragprog.com/titles/tsgit/pragmatic-version-control-using-git .

http://pragprog.com/titles/ctelec/a-peek-at-computer-electronics

I really like the concept, and it fits in with a bunch of techniques we've been using at work in line with the "Big Visible Charts" ideas. Things like this and Agile stories written on index cards and pinned to the wall do sound hokey. A number of people like Johanna Rothman http://www.pragprog.com/titles/jrpm however point out, that these techniques are a lot more inclusive and (as I've found) you get much more animated discussions than the pm/architect/team lead writing a document "for discussion."
If nothing else it's fun to watch management trying to cope with your walls being covered with sheets of paper, cards and string when they've paid all this money for MS Project and the Rational Suite.

I saw the presentation he mentioned and there's no clear answer at the end of it
to the question "where to tomorrow's novices opportunities come from?".
Outsourcing today takes the opportunity to gain footing on the
bottom 2-3 rungs off the 5 step skills ladder. We can't all be advanced
and experts without having spent the time to get there.

End of the Knowledge Worker?
http://blogs.pragprog.com/cgi-bin/pragdave.cgi/Pra ctices/ValueWorker.rdoc

Saw his presentation on this and there's no clear answer at the end
to the question "where to tomorrow's novices opportunities come from?".
Outsourcing today takes the opportunity to gain footing on the
bottom 2-3 rungs off the 5 step skills ladder. We can't all be advanced
and experts without having spent the time to get there...

I almost forgot - practice makes perfect, so try the Code Kata.

Uhhh...

Support for saving database records using database function. In other words, I want Rails to automatically perform a query that looks like this...

Create a column called "created_at" and Rails does it automatically according to which db adapter you're using. No function call (on your end) needed.

- Apache integration is still too immature. I don't know about Apache 1, but Apache 2 integration using FastCGI doesn't work *at all*. The documentation on the website about Apache integration is very messy: different pages suggest different things. After much research I found out that

I think the Agile Web Development with Rails book addresses this and I know that my book does, but either way that configuration is quickly becoming a thing of the past. FastCGI is slow, cumbersome, and hard to configure compared to using mod_proxy and pointing at a bunch of Mongrel (a Ruby/C based web server) instances. If you must use this setup, then look here: http://wiki.rubyonrails.org/rails/pages/FastCGI

If you really want the best setup, look here and here.

Documentation is still too immature. While the API references are pretty good, the Wiki is very messy (see Apache integration).
Agreed and work is being done on that, but don't discount Rails because of the bad wiki. Hit up Planet RubyOnRails, Planet Ruby, and RubyCorner: Ruby blogs are where the info is. If you like what you see, shell out the money for one of the books. I don't know if Ruby for Rails is a great place to start, but however you think you'll learn best, go with it: learning the language first (Ruby for Rails), learn the language from the framework (Agile Web Development with Rails), or a quick (50~ page)run through and then Rails (Mr. Neighborly's Relevant Ramblings, Thoughtful Theories, and Pointed Pontifications on Ruby and Rails -- my book).

-Jeremy

Ok Gina, let's talk the Dreyfus Model of Skill Acquisition as it applies to building software. Dave Thomas of Pragmatic Programmer fame has a nice article here discussing why this model describes how people learn to build software. Now answer me this: when things like "application maintenance" and "base application development" become the 1st things to be outsourced, what are you supposed to do with those freshly minted C.S. majors? You know, the ones with no practical experience in a development cycle? How are they supposed to become Experts (as Dave Thomas asks) when all the tasks that give the novice and beginner ranks the foundation to be experts don't get done by the local team? Do you want them on YOUR team, taking the chance of messing up mission critical work that they have limited frame of reference for? You can't kill a career path for cost savings and expect to magicly maintain a profession you rely on.

I'm amazed that you don't see the plain truth in numbers, Gina: the jobs being outsourced as people with experience move around and adjust (fighting tooth and nail, thank-you very much) aren't so much being "stolen" these days as they are never being created. All those drops in enrolement see the same thing Dave Thomas' article is talking about: no career path, too much risk.

Now for the last question: the one that probably makes for the icing on the cake in terms of why US and EMEA students are keeping away from C.S.. How long before that maintainable Dryfus Model of Skill Aquisition in other counteries like India and China turns into a competative force against US and EMEA businesses? Is it 14 years? Long enough to get through university, rack up student loan debt, and pay it off? No?!?! Do you honestly think that those countries are going to be content for 14 years to take scraps of "application maintenance" and "base application development" without any domestic business and technical growth? Until the attitude of companies changes towards fostering the software building career path instead of taking the first 3 rungs off the latter: you and your Fortune 500 ilk have made your bed Gina, now lie in it.

The Apple Developer Connection doesn't supply any attribution for their articles, but this one was written by none other than Mike Clark, who along with Dave Thomas runs the always-sold-out Pragmatic Studio series of Ruby on Rails and Ajax training.

Great to see Ajax in Action out there. It is a nice size volume, and talks about important ideas in Ajax.

There are other books out too, such as Foundations of Ajax, and the new Pragmatic Ajax (http://pragprog.com/titles/ajax) done by the Ajaxian guys (http://ajaxian.com/)

I think the Pragmatic Programmers do just that.

It was 1000 sold the week of memorial day. It is fair to assume that way more people use rails than bought the book during that week.
One of the authors blogging about the success

Apparently there were a few people who bought the book the first week-end...

http://blogs.pragprog.com/cgi-bin/pragdave.cgi/Ran dom/RailsBeta2.rdoc

I've got the Rails book, and it's amazing how many people have contributed errata and feedback (which by the way was quickly written and deployed with Ruby on Rails, the subject of the book). This might be the perfect way for authors to polish their books to a mirror shine before printing, especially if the content is something readers are eager for.

It could also be a way publishers can gauge the success of a book. No public feedback, not likely the book will sell well. Enthusiastic readers can participate in something they think is worthwhile, which of course can create favourable word of mouth.

Either way, the idea of an errataWiki and forum-like discussion on each section of a book is an interesting idea, and one that will be explored by other authors.

As mentioned in Curt's great article, the Agile Web Development with Rails (beta) book has a nice chapter on Ajax support. You can even get an extract of the chapter at the pragmatic programmer's site: PDF Extract of Chap 18: Web 2.0

Figure 18.1 should make Ajax clear. The book is highly recommended, and the 2nd Beta was just released last week.

I just downloaded it here

http://media.pragprog.com/STksl039cbjk7893gf78sdf7 g80ee.html

let's see if they get suspicious about 100 or so clicks...

http://pragprog.com/pragdave/Practices/Kata

For the lazy or doubtful, here's the list of descriptions:

KataOne: Supermarket pricing. Pricing looks easy, but scratch the surface and there are some interesting issues to consider.
KataTwo: Karate Chop. A binary chop algorithm is fairly boring. Until you have to implement it using five totally different techniques.
KataThree: How Big, How Fast? Quick estimation is invaluable when it comes to making design and implementation decisions. Here are some questions to make you turn over the envelope.
KataFour: Data Munging. Implement two simple data extraction routines, and see how much they have in common.
KataFive: Bloom Filters. Implement a simple hash-based lookup mechanism and explore its characteristics.
KataSix: Anagrams. Find all the anagram combinations in a dictionary.
KataSeven: Reviewing. What does our code look like through critical eyes, and how can we make our eyes more critical?
KataEight: Objectives. What effects do our objectives have on the way we write code?
KataNine: Checkout. Back to the supermarket. This week, well implement the code for a checkout system that handles pricing schemes such as "apples cost 50 cents, three apples cost $1.30."
KataTen: Hash vs. Class. Is it always correct to use (for example) classes and objects to structure complex business objects, or couple simpler structures (hash as Hashes) do the job?
KataEleven: Sorting it Out. Just because we need to sort something doesnt necessarily mean we need to use a conventional sorting algorithm.
KataTwelve: Best Sellers. Consider the implementation of a top-ten best sellers list for a high volume web store.
KataThirteen: Counting Lines. Counting lines of code in Java source is not quite as simple as it seems.
KataFourteen: Trigrams. Generating text using trigram analysis lets us experiment with different heuristics.
KataFifteen: Playing with bits. A diversion to discover the pattern in some bit sequences.
KataSixteen: Business Rules. How can you tame a wild (and changing) set of business rules?
KataSeventeen: More Business Rules. The rules that specify the overall processing of an order can be complex too, particularly as they often involve waiting around for things to happen.
KataEighteen: Dependencies. Lets write some code that calculates how dependencies propagate between things such as classes in a program.
KataNineteen: Word chains. Write a program that solves word chain puzzles (cat -> cot -> dot -> dog).
KataTwenty: Klondike. Experiment with various heuristics for playing the game Klondike.
KataTwentyOne: Simple Lists. Play with different implementations of a simple list.

mahlen

Try the Code Katas on the website of one the Pragmatic Programmers.

Have a look at CodeKata, coding practice sessions. Doing one of these occasionally (start of each week?) may help you get into the right frame of mind/attitude.