Commencez à lire Agile Software Engineering with Visual Studio: From Conce... sur votre Kindle dans moins d'une minute. Vous n'avez pas encore de Kindle ? Achetez-le ici Ou commencez à lire dès maintenant avec l'une de nos applications de lecture Kindle gratuites.

Envoyer sur votre Kindle ou un autre appareil

 
 
 

Essai gratuit

Découvrez gratuitement un extrait de ce titre

Envoyer sur votre Kindle ou un autre appareil

Tout le monde peut lire les livres Kindle, même sans un appareil Kindle, grâce à l'appli Kindle GRATUITE pour les smartphones, les tablettes et les ordinateurs.
Agile Software Engineering with Visual Studio: From Concept to Continuous Feedback (2nd Edition)
 
Agrandissez cette image
 

Agile Software Engineering with Visual Studio: From Concept to Continuous Feedback (2nd Edition) [Format Kindle]

Sam Guckenheimer , Neno Loje

Prix conseillé : EUR 23,68 De quoi s'agit-il ?
Prix éditeur - format imprimé : EUR 35,03
Prix Kindle : EUR 16,58 TTC & envoi gratuit via réseau sans fil par Amazon Whispernet
Économisez : EUR 18,45 (53%)

Formats

Prix Amazon Neuf à partir de Occasion à partir de
Format Kindle EUR 16,58  
Broché EUR 34,80  

Auteurs, publiez directement sur Kindle !

KDP
Via notre service de Publication Directe sur Kindle, publiez vous-même vos livres dans la boutique Kindle d'Amazon. C'est rapide, simple et totalement gratuit.
-40%, -50%, -60%... Découvrez les Soldes Amazon jusqu'au 5 août 2014 inclus. Profitez-en !





Descriptions du produit

Présentation de l'éditeur

Using agile methods and the tools of Visual Studio 2010, development teams can deliver higher-value software faster, systematically eliminate waste, and increase transparency throughout the entire development lifecycle. Now, Microsoft Visual Studio product owner Sam Guckenheimer and leading Visual Studio implementation consultant Neno Loje show how to make the most of Microsoft’s new Visual Studio 2010 Application Lifecycle Management (ALM) tools in your environment.

 

This book is the definitive guide to the application of agile development with Scrum and modern software engineering practices using Visual Studio 2010. You’ll learn how to use Visual Studio 2010 to empower and engage multidisciplinary, self-managing teams and provide the transparency they need to maximize productivity. Along the way, Guckenheimer and Loje help you overcome every major impediment that leads to stakeholder dissatisfaction–from mismatched schedules to poor quality, blocked builds to irreproducible bugs, and technology “silos” to geographic “silos.”

 

Coverage includes
• Accelerating the “flow of value” to customers in any software project, no matter how large or complex
• Empowering high-performance software teams and removing overhead in software delivery
• Automating “burndowns” and using dashboards to gain a real-time, multidimensional view of quality and progress
• Using Visual Studio 2010 to reduce or eliminate “no repro” bugs
• Automating deployment and virtualizing test labs to make continuous builds deployable
• Using Test Impact Analysis to quickly choose the right tests based on recent code changes
• Working effectively with sources, branches, and backlogs across distributed teams
• Sharing code, build automation, test, project and other data across .NET and Java teams
• Uncovering hidden architectural patterns in legacy software, so you can refactor changes more confidently
• Scaling Scrum to large, distributed organizations

 

Whatever your discipline, this book will help you use Visual Studio 2010 to focus on what really matters: building software that delivers exceptional value sooner and keeps customers happy far into the future.

 

 

Biographie de l'auteur

Sam Guckenheimer
When I wrote the predecessor of this book, I had been at Microsoft less than three years. I described my history like this:I joined

 

Microsoft in 2003 to work on Visual Studio Team System (VSTS), the new product line that was just released at the end of 2005. As the group product planner, I have played chief customer advocate, a role that I have loved. I have been in the IT industry for twenty-some years, spending most of my career as a tester, project manager, analyst, and developer.

 

As a tester, I�??ve always understood the theoretical value of advanced developer practices, such as unit testing, code coverage, static analysis, and memory and performance profiling. At the same time, I never understood how anyone had the patience to learn the obscure tools that you needed to follow the right practices.

 

As a project manager, I was always troubled that the only decent data we could get was about bugs. Driving a project from bug data alone is like driving a car with your eyes closed and only turning the wheel when you hit something. You really want to see the right indicators that you are on course, not just feel the bumps when you stray off it. Here, too, I always understood the value of metrics, such as code coverage and project velocity, but I never understood how anyone could realistically collect all that stuff.

 

As an analyst, I fell in love with modeling. I think visually, and I found graphical models compelling ways to document and communicate. But the models always got out of date as soon as it came time to implement anything. And the models just didn�??t handle the key concerns of developers, testers, and operations.

 

In all these cases, I was frustrated by how hard it was to connect the dots for the whole team. I loved the idea in Scrum (one of the Agile processes) of a �??single product backlog�??�??one place where you could see all the work�??but the tools people could actually use would fragment the work every which way. What do these requirements have to do with those tasks, and the model elements here, and the tests over there? And where�??s the source code in that mix?

 

From a historical perspective, I think IT turned the corner when it stopped trying to automate manual processes and instead asked the question, �??With automation, how can we reengineer our core business processes?�?? That�??s when IT started to deliver real business value.

 

They say the cobbler�??s children go shoeless. That�??s true for IT, too. While we�??ve been busy automating other business processes, we�??ve largely neglected our own. Nearly all tools targeted for IT professionals and teams seem to still be automating the old manual processes. Those processes required high overhead before automation, and with automation, they still have high overhead. How many times have you gone to a 1-hour project meeting where the first 90 minutes were an argument about whose numbers were right?

 

Now, with Visual Studio, we are seriously asking, �??With automation, how can we reengineer our core IT processes? How can we remove the overhead from following good process? How can we make all these different roles individually more productive while integrating them as a high performance team?�??

 

Obviously, that�??s all still true.

 

Neno Loje

I started my career as a software developer�??first as a hobby, later as profession. At the beginning of high school, I fell in love with writing software because it enabled me to create something useful by transforming an idea into something of actual value for someone else. Later, I learned that this was generating customer value.

 

However, the impact and value were limited by the fact that I was just a single developer working in a small company, so I decided to focus on helping and teaching other developers. I started by delivering pure technical training, but the topics soon expanded to include process and people, because I realized that just introducing a new tool or a technology by itself does not necessarily make teams more successful.

 

During the past six years as an independent ALM consultant and TFS specialist, I have helped many companies set up a team environment and software development process with VS. It has been fascinating to watch how removing unnecessary, manual activities makes developers and entire projects more productive. Every team is different and has its own problems. I�??ve been surprised to see how many ways exist (both in process and tools) to achieve the same goal: deliver customer value faster though great software.

 

When teams look back at how they worked before, without VS, they often ask themselves how they could have survived without the tools they use now. However, what had changed from the past were not only the tools, but also the way they work as a team.

 

Application Lifecycle Management and practices from the Agile Consensus help your team to focus on the important things. VS and TFS are a pragmatic approach to implement ALM (even for small, nondistributed teams). If you�??re still not convinced, I urge you to try it out and judge for yourself.

 


Détails sur le produit

  • Format : Format Kindle
  • Taille du fichier : 5960 KB
  • Nombre de pages de l'édition imprimée : 352 pages
  • Utilisation simultanée de l'appareil : Jusqu'à  appareils simultanés, selon les limites de l'éditeur
  • Editeur : Addison-Wesley Professional; Édition : 2 (15 septembre 2011)
  • Vendu par : Amazon Media EU S.à r.l.
  • Langue : Anglais
  • ASIN: B005N8EX1G
  • Synthèse vocale : Activée
  • X-Ray :
  •  Souhaitez-vous faire modifier les images ?


En savoir plus sur les auteurs

Découvrez des livres, informez-vous sur les écrivains, lisez des blogs d'auteurs et bien plus encore.

Commentaires en ligne 

Il n'y a pas encore de commentaires clients sur Amazon.fr
5 étoiles
4 étoiles
3 étoiles
2 étoiles
1 étoiles
Commentaires client les plus utiles sur Amazon.com (beta)
Amazon.com: 5.0 étoiles sur 5  9 commentaires
5 internautes sur 5 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Great Book!!!!! A MUST HAVE Scrum/TFS Resource 29 septembre 2011
Par T. Anderson - Publié sur Amazon.com
Format:Broché|Achat vérifié
I own the first version of this book and was looking forward to the second version. I would say if you want to get familiar with doing Scrum with TFS this is the book you want. It really does not cover the other templates at all. I am not saying that is bad, but it is not what I expected or wanted. I already have read enough on Scrum to last me a lifetime. I wanted to see more on the other templates.

All that said, if you have not had the opportunity to get familiar with Scrum this is a great place to get started, especially if you use TFS.

The book starts out with an introduction to agile, Scrum, and Visual Studio. It then digs into Scrum and TFS with chapters on Product Ownership, Running the Sprint, Architecture, Development, Build and Lab, Test, Lessons Learned at Microsoft Developer Division, and Continuous Feedback.

My favorite chapters were Development, Build and Lab, and Test. The author did a great job of showing all the different features available in TFS and Visual Studio that enable continuous integration, automating testing, and detecting programming errors early. The chapters go into enough detail to give you a really good understanding of the tools available and when to use them.

The architecture chapter did a good job of showing how to take advantage of the tools in Visual Studio for reverse engineering existing applications. It does not however show you how to use them to architect an application. Instead the author plays the "Emerging Architecture" trump card, and writes it off to it not being needed in agile processes. I guess this is ok, because the tools in Visual Studio are not ready for prime time when it comes to designing an Architecture. They are good for reverse engineering an application. I wholly disagree with the "Emerging Architecture" agile approach and believe it contributes to most of the messes that come out of teams claiming to be agile, but I won't ding the book for it since it is after all what agile prescribes.

One thing I noticed is there are quite a few typos. They are no big deal, just very obvious ones which was strange.

Personally I think the book should have been titled "Developing with Visual Studio and TFS using the Scrum Template". That is not a bad thing if that is what you want. The book is well written and an easy read. I think is does what it set out to do and it does it well. It is a top notch book.

I highly recommend it to anyone looking to learn Scrum and wants to use the TFS toolset to enable your team to accomplish your mission.
4 internautes sur 4 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 The definitive guide on agile development with Visual Studio 2010 9 novembre 2011
Par Ognjen Bajic - Publié sur Amazon.com
Format:Broché|Achat vérifié
Agile software development methodologies have been proven on projects large and small. Nowadays methodology of choice is Scrum. It empowers multidisciplinary teams to successfully implement complex software and ensures the continuous flow of value through the development process.

This book will teach you how to successfully implement Scrum using integrated set of tools from Microsoft Visual Studio 2010 (VS) and the Team Foundation Server 2010 (TFS) and create automated process maximizing flow of value. In addition to the usual sprint and daily cycles, TFS based implementation of such process also exhibits micro cycles like check in and test. Ensuring the flow by making handoffs between team members as efficient as possible, by automating quality enforcing steps i.e. dones and gathering metrics without overhead at every cycle are cornerstones of this efficient process.

The book goes beyond teaching you how to apply Scrum using VS and TFS. Reinforcing the flow of value by introducing removal of waste (bug debt, partially implemented features, unfinished code etc.) impeding the flow and transparency pinpointing the weak spots in the process, further ensure success of the development project. Guckenheimer and Loje teach how to identify different types of waste and deal with them. They do a great job explaining how to read different reports and analyze dashboards to gain real-time insight in progress, quality and other aspects of your project.

VS and TFS aim at empowering the whole team.

Architects can analyze legacy code or continuously validate the current architecture with every daily build using layer diagram.
Developers will learn how to write clean code from the beginning and detect errors early. Different built in tools like check in policies or gated check-in help with that. Developers write or generate tests, check how effective they are and efficiently use them by executing only the tests impacted by a recent change from the set of all tests.
Testers use simple but efficient tools to find bugs and fill rich bug reports (backed by video recording, debugger level Intellitrace information, test steps etc.). Such bugs are easily reproducible and can be quickly analyzed and resolved.
Automated tests executed in virtualized test environments as a part of the build process with automated deployment are very powerful means to fight regressions.

In the third part of the book, author shares valuable experiences from Microsoft, where the team that produces TFS and VS struggled with quality and schedule. By introducing many of the same techniques described in the book, in the last several years, they regained control. The last chapter shows glimpses of the future tools from the VS vNext.

The authors of this book succeeded in two conflicting tasks: to offer clear, high level overview of modern agile software engineering practices on one side and on the other to dig deep enough in all the tools available in the Visual Studio 2010 and the TFS to show how they support these practices. Everything in an easy to read, moderately sized book.

I highly recommend this book to anyone involved with the software development, irrespective of the role they play. You will learn the proven practices and the toolset as well as the rationale for the prescribed development process.
2 internautes sur 2 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Exceptional Resource 12 février 2012
Par Chris Clements - Publié sur Amazon.com
Format:Broché|Achat vérifié
Full disclosure: I am a senior technical writer at Microsoft, have worked with Sam and Neno for some time, and have worked on these technologies for over six years.

That said, take it from someone who has done writing and a ton of reading on the subject matter that the authors cover in this book. It's simply an exceptional resource, written by two people I consider to be among the very best at what they do. Whether you are new to Agile, Scrum, Visual Studio, and/or Team Foundation Server, or a veteran with all of them, this book has something to offer. It is very, very thorough and insightful. A newcomer could use it to ramp up quickly -- it has incredible span across the subject matter. An expert will find new ideas or new ways of thinking about agile software engineering in here as well. The language is clear and easy to understand, the examples are poignant, and it's a very interesting read -- even for guys like me who have read volumes about this stuff. Again, keeping full disclosure in mind, I am recommending this book because I've read it and I think it's an outstanding and valuable resource.
1 internautes sur 1 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 A must have resource 22 janvier 2012
Par Matteo Emili - Publié sur Amazon.com
Format:Broché
This book covers lots of important parts in the development lifecycle of an application in a very clear and understandable way, making it a must for who works in the software engineering field.
It's invaluable because of its content, which spreads from Scrum basics, to Visual Studio Team Lab Management, and because of the way the content is written.
1 internautes sur 1 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Great book for starting with agile methodologies and Visual Studio 13 janvier 2012
Par Luis Fraile - Publié sur Amazon.com
Format:Broché
Are you writing .NET software with Visual Studio 2010? are you interested or already using Scrum or agile? are you interested in ALM? if so to any of these, this is your book.

I know Sam and Neno from time ago (disclosure), and they are two of the people who I really trust about creating software and using agile methodologies. With this book you will get a nice insight about how to use the Visual Studio ALM tools for team software development, covering topics as the agile concepts and values, and how to apply them in the software development process.

It is not a book about how to use Visual Studio in detail, it is a book which will guide you around the different processes you will need to do using Scrum.

So, a great book I would recommend to anyone starting or already familiar with agile, Scrum and/or Visual Studio 2010, a definitive must read.
Ces commentaires ont-ils été utiles ?   Dites-le-nous

Passages les plus surlignés

 (Qu'est-ce que c'est ?)
&quote;
Technical debt refers to work that needs to be done to achieve the potentially shippable threshold, such as fixing bugs, unit testing, integration testing, performance improvement, security hardening, or refactoring for sustainability. &quote;
Marqué par 5 utilisateurs Kindle
&quote;
The Agile Consensus stresses three fundamental principles that reinforce each other: 1. Flow of value, where value is defined by the customer who is paying for or using this project 2. Continual reduction of waste impeding the flow 3. Transparency, enabling team members to continually improve the above two &quote;
Marqué par 4 utilisateurs Kindle
&quote;
Indeed, this is exactly whats known as the empirical process model, based on what works well in product development and industries with continuous process control. &quote;
Marqué par 4 utilisateurs Kindle

Discussions entre clients

Le forum concernant ce produit
Discussion Réponses Message le plus récent
Pas de discussions pour l'instant

Posez des questions, partagez votre opinion, gagnez en compréhension
Démarrer une nouvelle discussion
Thème:
Première publication:
Aller s'identifier
 

Rechercher parmi les discussions des clients
Rechercher dans toutes les discussions Amazon
   



Rechercher des articles similaires par rubrique