►Check the below link for detailed post on "12 Principles of Agile Software Development"
http://www.softwaretestingmaterial.com/principles-agile-software-development/
►THANKS for taking the time to visit, I hope you SUBSCRIBE and enjoy the upcoming videos!
►Please SUBSCRIBE for More videos:
https://www.youtube.com/channel/UCIJGI_3XgnfUaSNQD8D2IMQ
►If you like this video, Please click on Like and Comment!
►Follow Us on Social Network:
►Google +: https://plus.google.com/u/0/112866700026030919889/posts
►Facebook: https://www.facebook.com/SoftwareTestingMaterial
►Twitter: https://twitter.com/STMWebsite
►Pinterest: https://www.pinterest.com/stmsite/
►Website: http://www.softwaretestingmaterial.com ►LinkedIn: https://www.linkedin.com/in/rajkumarsm/

The Principles of Clean Architecture
by Uncle Bob Martin
(@unclebobmartin)
Robert C. Martin, aka, Uncle Bob has been a software professional since 1970 and an international software consultant since 1990. In the last 40 years, he has worked in various capacities on literally hundreds of software projects. In 2001, he initiated the meeting of the group that created Agile Software Development from Extreme Programming techniques and served as the first chairman of the Agile Alliance. He is also a leading member of the Worldwide Software Craftsmanship Movement - Clean Code.
He has authored "landmark" books on Agile Programming, Extreme Programming, UML, Object-Oriented Programming, C++ Programming and most recently Clean Code and Clean Coder. He has published dozens of articles in various trade journals.He has written, directed and produced numerous "Code Casts" videos for software professionals.Bob is a regular speaker at international conferences and trade shows.Mr. Martin is the founder, CEO, and president of Uncle Bob Consulting, LLC and Object Mentor Incorporated.
Uncle Bob has published dozens of articles in various trade journals, and is a regular speaker at international conferences and trade shows.
Mr. Martin has authored and edited many books including:
• The Clean Coder
• Clean Code
• Agile Software Development: Principles, Patterns, and Practices.
• Designing Object Oriented C++ Applications using the Booch Method
• Agile Principles Patterns and Practices in C#
• Patterns Languages of Program Design 3
• More C++ Gems
• Extreme Programming in Practice
• UML for Java Programmers
http://www.meetup.com/Norfolk-Developers-NorDev/events/223533655/

Before diving into full-blown design patterns it is good to review what have become known as the Agile Design Principles. Maintaining an understanding of design principles is key as we use design patterns in our projects because the two are so closely tied together. In this hour session Tim Star will discuss the Single responsibility principle (SRP), Open Closed Principle (OCP), Liskov Substitution Principle (LSP), Interface Segregation Principle (ISP) and the Dependency Inversion Principle (DIP).

As leader of our Pivotal Labs London office, Robbie has seen his fair share of agile development projects. In this session he not only covers principles of agile, but more importantly shares his own experiences about how you can make them work in practice.
Speaker: Robbie Clutton, Office Director - London, Pivotal

READ FIRST:
UB doesn't talk about -all- 5 SOLID principals, only a couple. This video is more valuable that just "another SOLID talk". And it's a meetup, not a course.
If you want a more in-depth training on it, UB has that on his CleanCoders.com site. Very good vids there...very in depth on coding techniques and he codes a lot there.
If anyone wants to challenge whether UB is right or wrong about OO concepts, or bitch because he doesn't cover all 5 principles in this 1 hour casual meetup talk, I'll immediately delete your comment. He knows his shit and I get tired of this kind of bitching which happens a lot.
This talk is still very entertaining and informative so sit back, relax, and enjoy! Sometimes it's good for us to learn and understand the past, so that we do not make the same mistakes that have been made over and over again in this profession.
https://www.CleanCoders.com - ton of vids by UB, very in depth technically
http://www.WeDoTDD.com/interviews/companies/16
https://twitter.com/unclebobmartin
http://blog.cleancoder.com
https://blog.8thlight.com/uncle-bob/archive.html
Source:
This presentation was given by Uncle Bob on Feb 4, 2015 at the Arlington Lakes Golf Club in Arlington Heights, IL.
Schaumburg Microsoft .NET Technologies Meetup http://bit.ly/1hAO2ln
Be sure to change the video to 1080p when watching it
Recorded with my IPhone 6+ 1080p (60fps)
Side Note:
UB talks little about SR and DI toward the end, but it's more a talk around business and more top level tech talk around around decoupling code and history of coding (where the idea of decoupling stemmed from, how objects came into existence and why, and how programming languages were affected by it ended up providing polymorphism... and a lot of other interesting things around the importance of plug-in software....all indirectly related to the topic of SOLID itself as a whole.
The S.O.L.I.D. Principles of OO and Agile Design
What happens to software? Why does is rot over time? How does an Agile Development team prevent this rot, and prevent good designs from becoming legacy code? How can we be sure our designs are good in the first place? This talk presents the agile S.O.L.I.D. principles for designing object oriented class structures. These principles govern the structure and inter dependencies between classes in large object oriented systems.
The principles include: The Open Closed Principle, The Liskov Substitution Principle, and the Dependency Inversion Principle, among others.
About "Uncle Bob" Martin:
Robert C. Martin has been a software professional since 1970. In the last 35 years, he has worked in various capacities on literally hundreds of software projects. He has authored "landmark" books on Agile Programming, Extreme Programming, UML, Object-Oriented Programming, and C++ Programming. He has published dozens of articles in various trade journals. Today, He is one of the software industry's leading authorities on Agile software development and is a regular speaker at international conferences and trade shows. He is a former editor of the C++ Report and currently writes a monthly Craftsman column for Software Development magazine.
Mr. Martin is the founder, CEO, and president of Object Mentor Incorporated. Object Mentor is a sister company to Object Mentor International. Like OMI, Object Mentor is comprised of highly experienced software professionals who provide process improvement consulting, object-oriented software design consulting , training, and development services to major corporations around the world.

The development of a data warehouse starts with a data model. In this video tutorial from our Agile Data Warehouse design training course, expert author Michael Blaha will take you through the process of creating a data model.
More details on this Agile Data Warehouse Design training course, as well as more free lessons, can be found at http://oreil.ly/1S4zJcs.
YouTube: https://www.youtube.com/user/OreillyMedia
Facebook: https://www.facebook.com/OReilly/?fref=ts
Twitter: https://twitter.com/OReillyMedia
Website: http://www.oreilly.com/

In this IMO (In My Opinion) video, software developer Steve Bishop will be talking to industry icon Robert C. Martin, better known as Uncle Bob. Uncle Bob is one of the original authors of the Agile Manifesto, and the Software Craftsmanship Manifesto. Uncle Bob has also written several books including "Agile Software Development, Principles, Patterns, and Practices", "Agile Principles, Patterns, and Practices in C#", "Clean Code: A Handbook of Agile Software Craftsmanship", "The Clean Coder: A Code of Conduct for Professional Programmers", and coming out next year "Clean Architecture". Robert Martin is also widely known as the creator of the SOLID principles, a advocate of Test Driven Development, and the Craftsmanship Movement.
You can ask your questions in the live chat and if we have time we'll ask them of Uncle Bob.
Gartman Technical Services: http://http://gartmantechnical.com/
Programming Made EZ: http://ProgrammingMadeEZ.com
Clean Coders Website: https://cleancoders.com/
Uncle Bob's Blog (Clean Coder Blog): http://blog.cleancoder.com/
Clean Architecture (Amazon): https://www.amazon.com/Clean-Architecture-Robert-C-Martin/dp/0134494164/ref=sr_1_2?ie=UTF8&qid=1479503189&sr=8-2

How did our industry start, what paths did it take to get to where we are, and where is it going. What big problems did programmers encounter in the past? How were they solved? And how do those solutions impact our future? What mistakes have we made as a profession; and how are we going to correct them. In this talk, Uncle Bob describes the history of software, from it’s beginnings in 1948 up through the current day; and then beyond. By looking at our past trajectory, we try to plot out where our profession is headed, and what challenges we’ll face along the way.
Robert C. Martin (Uncle Bob) has been a programmer since 1970. He is the Master Craftsman at 8th Light inc, an acclaimed speaker at conferences worldwide, and the author of many books including: The Clean Coder, Clean Code, Agile Software Development: Principles, Patterns, and Practices, and UML for Java Programmers.

In this episode, Robert is joined by Phil Japikse for a chat about design patterns. Software design patterns have been around long before the MVC Framework gained momentum. Phil starts with a review of Robert C. Martin's (Uncle Bob) SOLID macronym. After building the proper foundation,he reviews several design patterns, their C# implementation and when and how they should be used in modern software development.
Get the code samples here: http://www.skimedic.com/samples/Japikse_SolidPatterns.zip

Everything you ever wanted to know about how to estimate software tasks, and how to communicate those estimates to the business. We’ll discuss honesty, accuracy, and precision; and the best ways to satisfy all three.
Uncle Bob has been a programmer since 1970. He served as the Master Craftsman at 8th Light inc, is co-founder of the on-line video training company: cleancoders.com, and founder of Uncle Bob Consulting LLC. He is an acclaimed speaker at conferences worldwide, and the author of many books including: The Clean Coder, Clean Code, Agile Software Development: Principles, Patterns, and Practices, and UML for Java Programmers. He is a prolific writer and has published hundreds of articles, papers, and blogs. He served as the Editor-in-chief of the C++ Report, and as the first chairman of the Agile Alliance. He is the creator of the acclaimed Clean Code educational video series at cleancoders.com.
For more on YOW! Conference, visit http://www.yowconference.com.au

The trajectory of Agile methods continues upwards and outwards; not only into new organizations and industries, but increasingly beyond the realm of technology. This is leading to a set of cascading challenges and opportunities that lie in the application of Agile values, principles and practices to non-software domains.
This workshop will explore a jargon-free framework based upon lean and agile methods that is easily grasped and applied in non-software development contexts. Examples of real-world applications in human resources, marketing, real estate, education and more will be shared and discussed, and exercises will help participants plot out how these methods might be applied in their own personal contexts.
See more at https://lithespeed.com/

Robert Martin (@unclebobmartin) has been a programmer since 1970. He is the Master Craftsman at 8th Light inc, an acclaimed speaker at conferences worldwide, and the author of many books including: The Clean Coder, Clean Code, Agile Software Development: Principles, Patterns, and Practices, and UML for Java Programmers.
Chat Conversation End

Software Development Organizations are giving greater importance to gauge their competency/maturity levels in terms of different certifications like CMMI & ISO Certifications. This is because, clients of these Organizations rely on these Certifications/maturity levels to be assured that the best processes are being followed which enable them to get their intended solutions /deliveries in terms of consistent, quality products/ solutions delivered on time. From the Software Development Organization's perspective, these maturity levels help them to standardize the set of processes that could be made applicable to all the projects across the Organization, there by establishing consistency.
As part of the Software Development methodologies, Agile methodologies (like Scrum, Extreme Programming etc.) have been gaining more popularity in Software Organizations due to their inherent benefits. While Agile principles and practices have been followed for many years, there are lot of myths about Agile and an increasing confusion as to whether Agile practices can supplement CMMI process areas. This presentation aims to clarify on how Agile practices contribute to the achievement of the different CMMI Process areas and their goals and practices. It would also describe the practices that are comparable or similar in Agile and CMMI process areas and illustrate maturity levels that can be achieved using Agile practices.

Watch more from the O'Reilly Software Architecture Conference: http://goo.gl/lXpXnG
There is a common misconception that architecture is thrown out the window when a team or organization is developing software in an agile fashion, but where does this myth stem from? Surely, there is some truth behind this thinking. We’ll talk about some of the underlying assumptions that support this belief in order to build a common understanding of what it really means to be developing in an agile fashion. During the second half of this talk, we’ll move from the conceptual thinking into some practical suggestions from our experiences — what we’ve seen that works and highlight some practices to avoid. In the end, the audience will know how to bring architectural thinking into teams to support the higher level goals of application architecture.
About Molly Dishman (ThoughtWorks):
Molly Dishman is a Senior Consultant at ThoughtWorks Inc. a global IT Software Consultancy. During her ThoughtWorks career she has developed top quality software solutions for clients all over the world. She has been a trainer, developer, technical lead and coach during her time at ThoughtWorks. Molly is passionate about solving technical problems and helping others grow and learn software development.
About Martin Fowler (ThoughtWorks):
Martin is an author, speaker, consultant and self-described general loud-mouth on software development. He concentrates on designing enterprise software – looking at what makes a good design and what practices are needed to come up with good design. Fowler has been a pioneer of various topics around object-oriented technology and agile methods, and written several books including “Refactoring”, “UML Distilled”, “Patterns of Enterprise Application Architecture”, and “NoSQL Distilled”. For the last decade he’s worked at ThoughtWorks, what he considers a “really rather good” system delivery and consulting firm, and writes at http://martinfowler.com.
For more information, visit: http://oreil.ly/1Cyt9nt
Software architecture is a massive multidisciplinary subject, covering many roles and responsibilities, which makes it challenging to teach because so much context is required for every subject. It's also a fast-moving discipline, where entire suites of best practices become obsolete overnight.
The O'Reilly Software Architecture Conference is a new event designed to provide the necessary professional training that software architects and aspiring software architects need to succeed. A unique event, it covers the full scope of a software architect's job, from IT to leadership and business skills. It also provides a forum for networking and hearing what other professionals have learned in real-world experiences.
Stay Connected to O'Reilly Media by Email - http://goo.gl/YZSWbO
Follow O'Reilly Media:
http://plus.google.com/+oreillymedia
https://www.facebook.com/OReilly
https://twitter.com/OReillyMedia

The Agile Principles, Patterns, and Practices for creating Robust System Architectures. (SOLID PPP)
This course is a deep dive into the well--known SOLID principles of Agile and Object Oriented Design. Students will learn the characteristics of sound Object--Oriented designs and architecture, and patterns and practices that create them. Principles include: The Single Responsibility Principle, The Open Closed Principle, The Liskov Substitution Principle, The Interface Segregation Principle, The Dependency Inversion Principle, and many others. Special attention is paid to Component oriented design, and the principles and patterns of large--scale component architecture.
The course is designed for developers with all levels of experience using the Java, C# or C++ programming language.. Beginners will obtain a firm grounding in the principles, patterns and practices, while experienced developers will be able to sharpen and refine their skills by learning how to apply the concepts more effectively.
Objectives
By the end of this course, you will know how to:
Understand and apply the principles of object--oriented design and dependency management
Learn professional practices that make projects succeed
Learn important design patterns and how and when to apply them
Be able to apply Test--Driven Development in the context of Object--Oriented Design Principles and Patterns
Coding for Readability and Maintainability
The Problems
The Objectives
Forms of Software Rot
Attributes of a Good Design
Clean Code Qualities
Professional Responsibilities
Automated testing, TDD and Refactoring Practices Review
Refactoring
Dependency Inversion Principle
Problems with Procedural Programming
Object--Oriented Programming
Problem addressed by DIP
The Dependency Inversion Principle
Dependency Inversion Heuristics
When is DIP appropriate⁄inappropriate
Example design violating DIP
Example designs conforming to DIP
Open⁄Closed Principle
Problem addressed by OCP
The Open⁄Closed Principle
When is OCP appropriate⁄inappropriate
Several Example designs violating OCP
Several example designs conforming to OCP
Liskov Substitution Principle
Problem addressed by LSP
The Liskov Substitution Principle
Example designs violating LSP
Example designs conforming to LSP
Relationship OCP⁄LSP
When is "instance of is" not an LSP problem
Interface Segregation
Problem addressed by ISP
The Interface Segregation Principle
Example designs violating ISP
Example designs conforming to ISP
When is ISP appropriate⁄inappropriate
Law of Demeter
Problem addressed by LoD
Example design violating LoD
Example designs conforming to LoD
When is LoD appropriate⁄inappropriate
Pro⁄Con discussion
Practices That Support the Principles
Simple Design
Automated Testing
Test--Driven Development
Refactoring
Teamwork
Pair Programming
Collective Ownership
Quick Design Sessions
Continuous Integration
Code⁄Design Reviews
Summary
Clean code
Professional Responsibilities
SOLID Principles
Packaging Principles
About the instructor
Robert C. Martin has been a software professional since 1970. In the last 35 years, he has worked in various capacities on literally hundreds of software projects. He has authored "landmark" books on Agile Programming, Extreme Programming, UML, Object--Oriented Programming, and C++ Programming. He has published dozens of articles in various trade journals. Today, he is one of the software industrys leading authorities on Agile software development and is a regular speaker at international conferences and trade shows. He is a former editor of the C++ Report and currently writes a monthly Craftsman column for Software Development magazine.

In this tutorial, We are going to cover what is Agile ? and What are its 12 Principles , Explaining agile to the newbiews,
AGILE Consist of the four major rules : -
Individuals and interactions over processes and tools:
Customer collaboration over contract negotiation
Responding to change over following a plan
Working software over comprehensive documentation
Each one is discussed with example and explained how it important in software testing.
Recommend Books :
- Foundations of Software Testing ISTQB Certification - https://amzn.to/2AZf21m
- Mastering Selenium WebDriver - https://amzn.to/2BXtLeY
- Selenium Framework Design in Data-Driven Testing -https://amzn.to/2B2MWCu
- Selenium Design Patterns and Best Practices - https://amzn.to/2BZkYZW
- Learning Selenium Testing Tools - https://amzn.to/2B1DteU
Join Facebook Group : Software Testing & Automation Discussion
https://www.facebook.com/groups/1856048111184930/?ref=bookmarks
Blog : https://scrolltes.com
Follow at Quora : https://www.quora.com/profile/Promode-1

Creating Agile software means you need to be able to prioritize different pieces of functionality based on how valuable they are to the customer. To do this you must be able to break large stories down into smaller ones. This cartoon shows you how to do that. If you'd like a free book on this topic, please see below...
I've published a book called "Starting Agile" that is designed to help you start your team's Agile journey out right. You can buy a copy from Amazon, but I'm giving free copies away to my subscribers from YouTube. You can signup for a copy at this link:
https://mailchi.mp/326ba47ba2e8/agile-list

Learn more advanced front-end and full-stack development at: https://www.fullstackacademy.com
In this tutorial, we give an overview of the S.O.L.I.D. Principles of Object-Oriented Design, a concept introduced by Robert C. Martin in 1995. These rules are designed to help a programmer develop software that is easy to maintain and extend.
Watch this video to learn:
- Three major signs of bad code
- How coding with S.O.L.I.D. in mind can help you avoid these pitfalls
- How S.O.L.I.D. can apply when coding in JavaScript

A Containerized and Decentralized Approach to Cloud-Ready Connectivity.
Microservices principles are revolutionizing the way applications are built, by enabling a more decoupled and decentralized approach to implementation, creating greater agility, scalability and resilience. These applications still need to be connected to one another, and to existing systems of record. Agile integration architecture brings the benefits of cloud-ready containerization to the integration space. It provides the opportunity to move from the heavily centralized ESB pattern to integration within more empowered and autonomous application teams. We look at the architectural differences in this approach compared to traditional integration, and also at how it enables more decentralized organizational structure better suited to digital transformation. You can read a more detailed paper on this approach at http://ibm.biz/AgileIntegArchPaper.
Many thanks to Integration Developer News (http://www.idevnews.com/) for their assistance in the preparation of this video.

The Agile Manifesto is comprised of four foundational values and 12 supporting principles which lead the Agile approach to software development.
Certified ScrumMaster® (CSM) Certification Training: https://www.simplilearn.com/agile-and-scrum/csm-certification-training?utm_campaign=Agile-Principles-6VdoDGGvU3U&utm_medium=SC&utm_source=youtube
Certified ScrumMaster (CSM) is a designation offered by Scrum Alliance to practitioners who have successfully completed a CSM course and demonstrate their understanding through the CSM test. A CSM performs the following functions:
1. Aids project teams in using Scrum effectively
2. Provides expertise above that of a typical Project Manager
3. Acts as a ‘servant leader’ and helps the team work together and learn framework
4. Protects the team from internal and external distractions
Simplilearn's CSM training program includes classroom training. It is the ideal course package for every aspiring professional who wants to make a career in Project Management.
The CSM course is focused on providing an improved understanding of Scrum methodologies and their implementation.
Who should do this course?
The following categories of professionals can take the ‘Certified ScrumMaster Training’ and obtain the certification:
1. Members of Scrum teams such as developers, ScrumMasters, and product owners
2. Managers of Scrum teams
3. Teams transitioning to Scrum
4. Professionals intending to pursue the Professional ScrumMaster certification
For more updates on courses and tips follow us on:
- Facebook : https://www.facebook.com/Simplilearn
- Twitter: https://twitter.com/simplilearn
Get the android app: http://bit.ly/1WlVo4u
Get the iOS app: http://apple.co/1HIO5J0

Newsletter signup (with exclusive discounts): https://iamtimcorey.com/general-sign-up (your email will be kept safe and you will not be spammed).
Source Code: https://iamtimcorey.com/design-patterns-dip/
When you are writing code, are you doing it right? That is a question that worries a lot of people, and it should probably at least be something every developer thinks through. Design patterns are best practice concepts that we can implement into our code to make it better in some way. Think of them as guardrails that keep our code safe. In this video, we are going to look at the fourth entry in the famous SOLID principle. The I stands for Interface Segregation Principle. We are going to dive into what it means, how it should change our programming practices, and how far we should take it.

How did our industry start, what paths did it take to get to where we are, and where is it going. What big problems did programmers encounter in the past? How were they solved? And how do those solutions impact our future? What mistakes have we made as a profession; and how are we going to correct them. In this talk, Uncle Bob describes the history of software, from it’s beginnings in 1948 up through the current day; and then beyond. By looking at our past trajectory, we try to plot out where our profession is headed, and what challenges we’ll face along the way.
Bob will be doing a brief book signing after the talk, so bring your favorite Uncle Bob book with you and get it signed by the author!
Robert Martin (Uncle Bob) (@unclebobmartin) has been a programmer since 1970. He is co-founder of the on-line video training company cleancoders.com and founder of Uncle Bob Consulting LLC. He served as Master Craftsman at 8th Light inc, is an acclaimed speaker at conferences worldwide, and the author of many books including The Clean Coder, Clean Code, Agile Software Development: Principles, Patterns, and Practices, and UML for Java Programmers. He is a prolific writer and has published hundreds of articles, papers, and blogs. He served as the Editor-in-chief of the C++ Report, and as the first chairman of the Agile Alliance. He is the creator of the acclaimed educational video series at cleancoders.com.

Speaker: Joshua Kerievsky (@JoshuaKerievsky), CEO @ Industrial Logic Inc.
Code that is difficult to understand, hard to modify and challenging to extend is hazardous to developers, users and organizations. Refactoring, or improving the design of existing code, is one of our greatest defenses against such code. In this talk, I’ll discuss the value of refactoring, how we practice it safely, when and why we refactor, the power of refactoring tools and when we avoid refactoring. I’ll be using several real-world examples of refactoring and sharing what I’ve learned about this important practice of the last 20 years.
About the speaker
Joshua is a globally recognized thought leader in Agile and Lean software development. He is an entrepreneur, author and programmer passionate about excellent software and discovering better, faster and safer ways to produce it. As the founder and visionary leader of Industrial Logic, Joshua is currently defining what it means to practice modern agility. Modern agile practitioners work to Make People Awesome, Make Safety A Prerequisite, Experiment & Learn Rapidly and Deliver Value Continuously. Joshua is a sought-after international speaker, author of the best-selling, Jolt Cola-award winning book, Refactoring to Patterns, and a guru-level practitioner of Lean/Agile methods. His pioneering work in Agile processes has helped popularize Agile Readiness Assessments, Chartering, Storytest-Driven Development and Iterative Usability, many of which are now standard in Agile/Lean processes. He is an active blogger on forward-thinking, modern software topics with an edge.
Event Page: http://2016.agilesingapore.org
Produced by Engineers.SG
Help us caption & translate this video!
http://amara.org/v/XvTI/

From OSCON 2015 in Portland: In the software world, architecture often gets a bad reputation. I’ll talk about why it matters, and how we can pay attention to it without falling into traps.
About Martin Fowler:
Martin Fowler is an author, speaker, consultant, and self-described general loudmouth on software development. He concentrates on designing enterprise software – looking at what makes a good design and which practices are needed to come up with good design. Fowler has been a pioneer of various topics around object-oriented technology and agile methods, and written several books including Refactoring, UML Distilled, Patterns of Enterprise Application Architecture, and NoSQL Distilled. For the last decade he’s worked at ThoughtWorks, which he considers a “really rather good” system delivery and consulting firm. He writes at martinfowler.com.
Watch more from OSCON 2015: https://goo.gl/vD6vda
Find out more about OSCON: http://oscon.com/open-source-2015
Don't miss an upload! Subscribe! http://goo.gl/szEauh
Stay Connected to O'Reilly Media by Email - http://goo.gl/YZSWbO
Follow O'Reilly Media:
http://plus.google.com/+oreillymedia
https://www.facebook.com/OReilly
https://twitter.com/OReillyMedia

Most programmers think architecture means combining a set of tools. They take frameworks like Hibernate, combine them with Spring and Struts, they deliver on Velocity templates and voilá, there is your architecture. Their applications reflect this way of thinking. They are built around these tools and they are organized in structures to satisfy the rules and conventions of these tools. Then programmers discover agile practices, principles, and patterns, and realize that many cool things can not be applied to their applications. They are reluctant to change the architecture because they don't know what to replace it with.
In this talk we will learn how to identify the architecture issues, what are the most important agile practices trying to tell us, and how to pull in existence an architecture that can accommodate practices like TDD and Unit Testing, respect the SOLID principles, and rely on basic design patterns.
Takeaways:
* architecture smells
* main technical agile practices
* concepts of clean architecture

This presentation was recorded at GOTO Aarhus 2012. #gotocon #gotoaar
http://gotocon.com
Joshua Kerievsky - Founder, Industrial Logic and Author of "Refactoring to Patterns"
ABSTRACT
Lean Startup is a disciplined, scientific and capital efficient method for discovering and building products and services that people love. Pioneered by entrepreneur and engineer, Eric Ries, the Lean Startup method will thoroughly change how you think about and practice agility. Born from the struggles and ultimate triumphs of successful software companies, Lean Startups use rigorous experimentation, careful measurement, validated learning and pivot/persevere decisions to systematically produce happy customers and successful businesses. In this talk, you'll learn why this decade will be dominated by the Lean Startup method and what you can do to make it a part of your process.
https://twitter.com/gotocon
https://www.facebook.com/GOTOConference
http://gotocon.com

Software design patterns have been around long before the MVC Framework gained momentum. In this session we will start with a review of Robert C. Martin's (Uncle Bob) SOLID macronym. After building the proper foundation, I will show you several design patterns, their C# implementation, and when and how they should be used in modern software development.
Guest speaker: Phil Japikse

Video Sponsor: PVS-Studio: https://bit.ly/2PeCS2v
Newsletter signup (with exclusive discounts): https://iamtimcorey.com/general-sign-up (your email will be kept safe and you will not be spammed).
Source Code: https://iamtimcorey.com/design-patterns-dry
Have you ever heard the term DRY, as in "Keep your code DRY"? DRY refers to one of the foundational design principles in programming. It stands for Don't Repeat Yourself. On the surface, that sounds so easy to do. However, as you will see in this video, there is a lot to think through when trying to get this right. From thinking through where to put code to ensuring that you don't repeat yourself in testing and bug fixing, there is a lot beneath the surface of simply keeping code DRY.

Breakout session from Software Architect 2013
http://software-architect.co.uk/
'Software Architect' is an annual technical conference for software architects and software developers. Featuring both full-day workshops and focused 90-minute breakout sessions, our expert speakers will ensure you and your team understand the fundamentals of software architecture and are up to date with the latest developments, ideologies and best practices.
Please visit http://software-architect.co.uk/ for information on the latest event.
-------------------------------------------------------------------------------------
'Software Architect' is part of DevWeek Events, a series of software development conferences and workshops, including the flagship DevWeek conference (http://devweek.com/), brought to you by Publicis Blueprint.
-------------------------------------------------------------------------------------

This presentation was recorded at GOTO Amsterdam 2015. #gotocon #gotoams
http://gotoams.nl
Pragmatic Dave Thomas - Pragmatic Programmer Turned Publisher
ABSTRACT
Dave Thomas was one of the creators of the Agile Manifesto. A year ago, he told us that Agile is Dead. How could this be? Why had he deserted us? And what are we to do?
It turns out that while the "Agile" industry is busy debasing [...]
Download slides and read the full abstract here:
http://gotocon.com/amsterdam-2015/presentation/EVENING%20KEYNOTE:%20Agile%20is%20Dead
https://twitter.com/gotoamst
https://www.facebook.com/GOTOConference
http://gotocon.com
#Agile #AgileIsDead

A trigger is a named PL/SQL unit that is stored in the database and executed ( fired ) in response to a specified event that occurs in the database.
Overview of Triggers.
A trigger is a named program unit that is stored in the database and fired (executed) in response to a specified event. The specified event is associated with either a table, a view, a schema, or the database, and it is one of the following:
A database manipulation (DML) statement ( DELETE , INSERT , or UPDATE )
A database definition (DDL) statement ( CREATE , ALTER , or DROP )
A database operation ( SERVERERROR , LOGON , LOGOFF , STARTUP , or SHUTDOWN )
The trigger is said to be defined on the table, view, schema, or database.

Trigger Types.
A DML trigger is fired by a DML statement, a DDL trigger is fired by a DDL statement, a DELETE trigger is fired by a DELETE statement, and so on.
An INSTEAD OF trigger is a DML trigger that is defined on a view (not a table). The database fires the INSTEAD OF trigger instead of executing the triggering DML statement. For more information, see Modifying Complex Views (INSTEAD OF Triggers).
A system trigger is defined on a schema or the database. A trigger defined on a schema fires for each event associated with the owner of the schema (the current user). A trigger defined on a database fires for each event associated with all users.
A simple trigger can fire at exactly one of the following timing points :
Before the triggering statement executes.
After the triggering statement executes.
Before each row that the triggering statement affects.
After each row that the triggering statement affects.
A compound trigger can fire at more than one timing point. Compound triggers make it easier to program an approach where you want the actions you implement for the various timing points to share common data. For more information, see Compound Triggers.
Trigger States.