Forgot your password?
typodupeerror

Comment: Re:This is completely NOT a forgotten author but.. (Score 1) 1244

by kabz (#39269651) Attached to: Ask Slashdot: Good, Forgotten Fantasy & Science Fiction Novels?
You know there was a sequel called 'secret of the sixth magic'... I loved that too. Always kinda reminded me of 'A Saturday Life', not sci-fi but fairly obscure I'd think. Anyway, Patrick Rothfuss probably read Master of the Five Magics, I think I can see a little coming through in his books.
Handhelds

+ - Nanowires boost laptop battery life to 20 hours

Submitted by brianmed
brianmed (131838) writes "Stanford researchers have found a way to use silicon nanowires to reinvent the rechargeable lithium-ion batteries that power laptops, cell phones, MP3 players and other portable devices. The new version, developed through research led by Yi Cui, assistant professor of materials science and engineering, produces up to 10 times the amount of electricity of existing lithium-ion batteries."
Education

+ - OLPC XO Review-> 1

Submitted by
BIOS_LEVEL
BIOS_LEVEL writes "The XO is the laptop produced by the One Laptop Per Child program (OLPC) headed by Mr. Nicholas Negroponte. The goal of OLPC is to provide every child a laptop which they can use to experience technology and the Internet. Through the Give One Get One program (G1G1), residents of North America are able donate $400 to the OLPC foundation, $200 of which finances a laptop for a child, and $200 of which pays for the cost of delivering one to the donor. Colin Dean was one of the first to participate in G1G1, and this is his review of it."
Link to Original Source
Programming

+ - Refactoring: Improving the Design of Existing Code

Submitted by
kabz
kabz writes "Refactoring: Improving the Design of Existing Code
Martin Fowler with Kent Beck, John Brant, William Opdyke and Don Roberts.
In the Addison-Wesley Object Technology Series.

Refactoring (as I'll refer to the book from here on in) is a heavy and beautifully produced 418 page hardback book. Martin Fowler is a UK-based independent consultant who has worked on many large systems and is the author of several other books including UML-Distilled.

Refactoring is a self-help book in the tradition of Code Complete by Steve McConnell. It defines its audience clearly as working programmers and provides a set of problems, a practical and easily followed set of remedies and a rationale for applying those techniques.

Code refactoring is the process of restructuringing code in a controlled way to improve the structure and clarity of code, whilst maintaining the meaning of the code being restructured. Many maintenance problems stem from poorly written code that has become overly complex, where objects are overly familiar with each other, and where solutions implemented expeditiously contribute to the software being hard to understand and hard to add features to.

Typically refactorings are applied over a testable or local scope, with existing behavior being preserved. Refactoring as defined in this book is not about fixing bad designs, but instead should be applied at lower levels.

Testing a la Extreme Programming is emphasized as a control for ensuring that program meaning is not changed by refactoring. It is not over emphasized, and this is not a book about testing, but it is often mentioned and stays in the background through the book.

The refactorings presented in the book are not intended as a comprehensive solution for all problems, but they do offer a means to regain control of software that has been implemented poorly, or where maintenance has been shown to simply replace old bugs with newer ones.

The book is divided into two main sections, introductory material that introduces and discusses refactorings, and a lengthy taxonomy of refactorings that includes both examples and further discussion. The introductory material consists of a long worked example through simple Java code that implements printing a statement for a video store. Despite the simplicity of the code, Fowler shows in clear detail where improvements can be made, and how those improvements make the code both impressively easy to understand, and easy to maintain and add features.

Several key refactorings are demonstrated in the opening chapter including Extract Method, Move Method and Replace Conditional with Polymorphism. This is a book about programming in the object oriented paradigm, so as you might expect, the first two refactorings refer to extracting and moving object methods either into new methods, or between objects. The third example provides a means to replace special cased behavior in a single object type by deriving a sub type of the object and moving type specific code to the sub types. This is a fundamental technique in object oriented programming, and is discussed here in practical terms.

Now that several actual refactorings have been introduced, Fowler provides a solid and well thought-out discussion of the why's, when's and when not's of refactoring. For example, code can decay as features are added, and programmers special-case, or bodge additional functionality into existing objects. Fowler argues that the bitrot and decay makes software more unreliable, leads to bugs and can accelarate as the problem gets worse. Faced with these problems, refactoring should be used to improve local design and clean up and improve code, leading to better software, that is easier to maintain, easier to debug, and easier to improve with new features as requirements change.

However, there is a caveat, in that since software functionality should remain unchanged during refactoring, the process of refactoring consumes resources, but provides no easily measureable value. Fowler confronts this issue in a section that discusses how to communicate with managers, that you are performing refactoring work. He denies being subversive, but his conclusion is that refactoring should essentially be folded in with normal work as it improves the overall result.

This is a bit like goofing off on the basis that you'll think better after 20 minutes of fooseball. I'd definitely subscribe to that theory, but many others may not.

Kent Beck guests in Chapter Three for a review of the issues in typical software that suggest a refactoring may be needed. This chapter is entitled Bad Smells in Code, and most of the smells presented will be familiar to any reasonably experienced programmer, and they will be a great learning experience for less experienced programmers. I got the same feeling reading this chapter as I did when I first read Code Complete. Here was someone writing down names and describing problems that I had a vague unease about, but was too inexperienced to really articulate or do something about. Typically the refactorings address the same kind of issues that a code review with a skilled experienced programmer would address. Long parameter lists, too long methods, objects delving about in each others private variables, case statements, related code spread across different objects etc. None of these problems are debiliting in themselves, but added up, they lead to software that can be prone to error and difficult to maintain.

Most of the remaining substance of the book, 209 pages, is given over to a taxonomy of refactorings. These 72 refactorings are covered in detail with comprehensive simple examples presented in Java. Each refactorings is given a clear name, a number and a line or two of descriptive text. The motivation for the refactoring is then discussed, often including caveats and cautions. The mechanics of implementing the refactoring are then listed, with 1 or more (and often more) examples of implementing the refactoring. Refactorings range from the very simple to more complex examples such as Convert Procedural Design to Objects.

Due to the difficulties of reproducing large and complex sections of code, Fowler sticks with relatively simple examples. These seem to grate on him more than the reader, and he can come across as somewhat embarrassed when we look at the employee, programmer, manager pay example for the tenth time. I certainly didn't have a problem with it though.

Conclusion

This is a very well written and fun to read book. I personally feel that much of the material is implied by from Code Complete, but Fowler does a fantastic job of expanding and formalizing the idea of applying explicit refactorings. Much like Code Complete gave a motivation for keeping code well commented and laid out, this book presents the case for care and feeding of how to structure software. To fight bitrot and technical debt, poorly structured and unclear code should be targetted and refactored to improve structure and clarity. This gives a very real payback in terms of less required maintenance, and ease in adding features later on down the line.

Despite the fact that all the examples are in Java, the ideas are easily transferable to C++ or any procedural object oriented language.

Highly recommended."
Programming

+ - Are you proud of your code? 6

Submitted by Anonymous Coward
An anonymous reader writes "I have a problem and I am hoping /. group therapy is the cure, so get on with the +5 comments, post haste! I am downright embarrassed by the quality of my work; specifically, my code. It is buggy, slow, fragile, and a nightmare to maintain. Documentation, requirements, automated tests? Does not exist. Do you feel the same way? If so, then what is holding you back from realizing your full potential? More importantly, what if anything are you planning to do about it? This picture, which many of you have already seen, captures several project failure modes. It would be humorous if it weren't so depressingly true. I enjoy programming and have from a young age (cut my teeth on BASIC on an Apple IIe). I have worked for companies large and small in a variety of languages and platforms. Sadly the one constant in my career is that I am assigned to projects that drift, seemingly aimlessly, from inception to a point where the client runs out of funding and the project is abandoned. Like many young and idealistic university graduates I hoped to spend my life programming passionately, but ten years later I look in the mirror and see a whore. I'm just doing it for the money. Have any developers here successfully lobbied their company to stop or cut back on 'cowboy coding' and adopt best practices? I'm not talking about the methodology-of-the-week, I'm referring to good old fashioned advice like keeping SQL out of the UI layer. For the big prize: has anyone convinced their superiors that the customer isn't always right and saying no once in awhile is the best course of action? Thanks in advance for your helpful advice."
Microsoft

+ - Linspire delivers Open XML translator->

Submitted by karmic_penguin
karmic_penguin (845053) writes "Linux distributor Linspire has delivered the first fruits of its controversial interoperability and patent deal with Microsoft in the form of Open XML Translator software for OpenOffice and Star Office. Microsoft's RT Audio Codec has been licensed to "enable voice-enabled interoperability between Linspire's Pidgin client and Microsoft's Office Communicator and Live Messenger instant messaging clients." Linspire has also licensed a number of Microsoft TrueType fonts and has agreed to support Windows Media 10 audio and video codecs. However, they will only be available to Linspire users if they purchase "a patent SKU", and this will not be available for Freespire. It remains to be seen if Microsoft will end up getting the better end of these interoperability agreements."
Link to Original Source
Databases

+ - Cache Method to Improve Application Performance

Submitted by
An anonymous reader writes "I am currently trying to speed up some processes that slurp up and process some amounts of data from moderately sized databases of several 10's of gigabytes.

I am looking at one approach to build an object layer that will serve as a cache / mediator between the main database and the clients, but I see issues with lazy writing, data merging, and multi-user access.

I currently read data into screens from ADO recordsets, and write similarly. Therefore I am looking at some rewriting to make screens and related code run against my home-grown object layer.

What do people think of this approach, and what other approaches might be suggested? Since some screens include summary and computed information, being able to run SQL against the cache would be a benefit and save me writing some code."

It's later than you think, the joint Russian-American space mission has already begun.

Working...