There’s plenty of material (documentation, blogs, books) out there that’ll help you write a site using Django… but then what? You’ve still got to test, deploy, monitor, and tune the site; failure at deployment time means all your beautiful code is for naught.
This tutorial examines how best to cope when the Real World intrudes on your carefully designed website.
Apache is an open source web server that is very popular, secure, fast, and reliable. It implements many features including CGI, SSL, virtual domains, and plug-in modules for extensibility. Apache uses simple text configuration files like httpd.conf to configure settings and is run from the command line using scripts like apachectl to start, stop, and restart the server.
Servlets are Java programs that run on a web or application server and act as a middle layer between a request coming from a web browser or other HTTP client and databases or applications on the HTTP server. Servlets receive HTTP requests and return HTTP responses by accepting request parameters, generating dynamic content, accessing databases, and performing network communications using Java. Servlets are commonly used to add dynamic content to web pages and to access backend databases. The lifecycle of a servlet involves initialization, servicing client requests, and destruction. Common servlet APIs include classes for handling HTTP requests and responses, reading request parameters, using cookies and sessions.
Operators are elements in C# that are applied to operands in expressions or statements. Unary operators take one operand, like increment (++), while binary operators take two operands, such as arithmetic operators (+, -, *, /). The conditional operator (?:) is the sole ternary operator, taking three operands. Some common operators are assignment (=), arithmetic, comparison, conditional (&&, ||), ternary (?:), and null coalescing (??). Operator precedence and associativity determine the order of evaluation in expressions with multiple operators. Parentheses can be used to override precedence.
This document provides an overview of ExpressJS, a web application framework for Node.js. It discusses using Connect as a middleware framework to build HTTP servers, and how Express builds on Connect by adding functionality like routing, views, and content negotiation. It then covers basic Express app architecture, creating routes, using views with different template engines like Jade, passing data to views, and some advanced topics like cookies, sessions, and authentication.
Debugging in JavaScript
It is common to have errors while writing codes and the errors can be due to syntax or logical. These errors create a lot of ambiguity in the logic and understanding of both users and programmers. There can also be errors in the code which can remain invisible to the programmer’s eye and can create havoc. To identify these errors we need Debuggers that can go through the entire code or program, identify the errors and also fix them.
-Debugger
The debugger keyword is used in the code to force stop the execution of the code at a breaking point and calls the debugging function. The debugger function is executed if any debugging is needed at all else no action is performed.
The document provides an overview of jQuery including:
- What jQuery is and its main features like DOM manipulation and AJAX
- How to include jQuery in an HTML document and basic usage syntax
- jQuery selectors to find elements and filters to refine selections
- Common jQuery methods for manipulating attributes, events, HTML, CSS, and more
- Examples of using various jQuery functions and concepts
Apache is an open source web server that is very popular, secure, fast, and reliable. It implements many features including CGI, SSL, virtual domains, and plug-in modules for extensibility. Apache uses simple text configuration files like httpd.conf to configure settings and is run from the command line using scripts like apachectl to start, stop, and restart the server.
Servlets are Java programs that run on a web or application server and act as a middle layer between a request coming from a web browser or other HTTP client and databases or applications on the HTTP server. Servlets receive HTTP requests and return HTTP responses by accepting request parameters, generating dynamic content, accessing databases, and performing network communications using Java. Servlets are commonly used to add dynamic content to web pages and to access backend databases. The lifecycle of a servlet involves initialization, servicing client requests, and destruction. Common servlet APIs include classes for handling HTTP requests and responses, reading request parameters, using cookies and sessions.
Operators are elements in C# that are applied to operands in expressions or statements. Unary operators take one operand, like increment (++), while binary operators take two operands, such as arithmetic operators (+, -, *, /). The conditional operator (?:) is the sole ternary operator, taking three operands. Some common operators are assignment (=), arithmetic, comparison, conditional (&&, ||), ternary (?:), and null coalescing (??). Operator precedence and associativity determine the order of evaluation in expressions with multiple operators. Parentheses can be used to override precedence.
This document provides an overview of ExpressJS, a web application framework for Node.js. It discusses using Connect as a middleware framework to build HTTP servers, and how Express builds on Connect by adding functionality like routing, views, and content negotiation. It then covers basic Express app architecture, creating routes, using views with different template engines like Jade, passing data to views, and some advanced topics like cookies, sessions, and authentication.
Debugging in JavaScript
It is common to have errors while writing codes and the errors can be due to syntax or logical. These errors create a lot of ambiguity in the logic and understanding of both users and programmers. There can also be errors in the code which can remain invisible to the programmer’s eye and can create havoc. To identify these errors we need Debuggers that can go through the entire code or program, identify the errors and also fix them.
-Debugger
The debugger keyword is used in the code to force stop the execution of the code at a breaking point and calls the debugging function. The debugger function is executed if any debugging is needed at all else no action is performed.
The document provides an overview of jQuery including:
- What jQuery is and its main features like DOM manipulation and AJAX
- How to include jQuery in an HTML document and basic usage syntax
- jQuery selectors to find elements and filters to refine selections
- Common jQuery methods for manipulating attributes, events, HTML, CSS, and more
- Examples of using various jQuery functions and concepts
This document discusses connecting to and interacting with MySQL databases from PHP. It covers connecting to a MySQL database server, selecting databases, executing SQL statements, working with query results, and inserting, updating and deleting records. Functions covered include mysql_connect(), mysql_query(), mysql_fetch_row(), mysql_affected_rows(), and mysql_info(). The document provides examples of connecting to MySQL, selecting databases, executing queries, and accessing and manipulating data.
Things you should know about Javascript ES5. A programming language that enables you to create dynamically updating content, control multimedia, animate images, and pretty much everything else
This document summarizes the history and benefits of AngularJS. It explains that AngularJS was originally created in 2009 as a side project by Misko Hevery and Adam Abrons to build a tool for both front-end and back-end development. When working on a Google project called Google Feedback, Hevery was able to rewrite 17,000 lines of code into 1,500 lines using his AngularJS framework by taking advantage of its features like separation of concerns, modularity, and reusable components. The document then lists some key benefits of AngularJS like being lightweight, free, and improving structure, quality, organization and maintainability of code.
The document provides an agenda and introduction for a Java training over multiple days. Day 1 will cover an introduction to Java including its history, features, programming paradigm, sample program execution, JVM, data types, objects, classes, variables, and flow control statements. The training will cover key Java concepts like objects, classes, variables, different loops and conditional statements. Assignments are provided to practice the concepts covered.
The document discusses the XML DOM (Document Object Model). It defines the DOM as a standard for accessing and manipulating XML documents through a tree structure representation. The DOM defines all elements in an XML document as nodes that can be traversed and modified. It outlines DOM properties and methods for navigating and manipulating the node tree. Advantages of the DOM include its traversable and modifiable tree structure, while disadvantages include higher resource usage compared to SAX parsing.
- Shell scripting allows users to automate repetitive tasks by writing scripts of shell commands that can be executed automatically. The shell acts as an interface between the user and the operating system kernel, accepting commands and passing them to the kernel for execution. Common shells used for scripting include Bash, C Shell, and Korn Shell. Shell scripts use shell commands, control structures, and functions to perform automated tasks like backups and system monitoring.
Spring I/O 2012: Natural Templating in Spring MVC with ThymeleafThymeleaf
Introduction to the Thymeleaf java XML/XHTML/HTML5 template engine by José Miguel Samper and Daniel Fernández at Spring I/O 2012 Madrid, Feb 17th 2012.
What is Yaml:
Human friendly, cross language, Unicode based data serialization language.
Pronounced in such a way as to rhyme with “camel”
Acronym for
YAML
Ain’t
A language used to convert or represent structured data or objects as a series of characters that can be stored on a disk.
Examples:
CSV – Comma separated values
XML – Extensible markup language
JSON – JavaScript object notation
YAML – YAML ain’t markup language
Markup
Language
This document discusses Node.js functions, modules, and exporting modules. It covers defining functions, parameters, and return values. It also covers the different types of modules in Node.js including core modules, local modules, and third party modules. Finally, it discusses how to export variables, functions, objects, and classes from modules using module.exports.
This document discusses delegates and events in C#. It explains that a delegate is an object that can refer to a method. There are four steps to using delegates: declaration, defining delegate methods, instantiation, and invocation. Delegates can be singlecast or multicast. Events are declared using an event keyword and a delegate type, and allow an object to notify other objects when an event occurs. Multicast delegates can invoke multiple methods by adding delegate instances together using + operator and removing them using - operator.
This document discusses various PHP functions and concepts related to working with databases in PHP, including:
- PHP functions for arrays, calendars, file systems, MySQL, and math
- Using phpMyAdmin to manage MySQL databases
- The GET and POST methods for passing form data
- SQL commands for creating, altering, and manipulating database tables
- Connecting to a MySQL database from PHP using mysql_connect()
It provides code examples for using many of these PHP functions and SQL commands to interact with databases. The document is an overview of key topics for learning PHP database programming.
SQLite is a C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine. It is often used for local/client storage in applications. Key points:
- Created by D. Richard Hipp, it provides a lightweight disk-based database that doesn't require a separate server process and allows accessing the database using SQL queries.
- The entire database is stored in a single cross-platform file and can be as small as 0.5MB, making it suitable for embedded and mobile applications.
- It supports common data types like NULL, INTEGER, REAL, TEXT, and BLOB and is used in standalone apps, local
This document provides an overview of Java servlets technology, including:
1. What Java servlets are and their main purposes and advantages such as portability, power, and integration with server APIs.
2. Key aspects of servlet architecture like the servlet lifecycle, the HttpServletRequest and HttpServletResponse objects, and how different HTTP methods map to servlet methods.
3. Examples of simple servlets that process parameters, maintain a session counter, and examples of deploying servlets in Eclipse IDE.
This document provides an overview of Angular, including:
- Angular is a JavaScript framework used to build client-side applications with HTML. Code is written in TypeScript which compiles to JavaScript.
- Angular enhances HTML with directives, data binding, and dependency injection. It follows an MVC architecture internally.
- Components are the basic building blocks of Angular applications. Modules contain components and services. Services contain reusable business logic.
- The document discusses Angular concepts like modules, components, data binding, services, routing and forms. It provides examples of creating a sample login/welcome application in Angular.
An assembly in .NET contains compiled code and metadata. It can be an EXE or DLL file. When code is compiled, it is translated to IL code and metadata is generated. The IL and metadata are bundled into the assembly file. Assemblies can be private, used by a single app, or shared, used by multiple apps. Shared assemblies are stored in the global assembly cache so they only need to be deployed once. The ILDASM tool allows examining the contents of an assembly.
The document discusses setting up and configuring an Apache Tomcat server. It includes steps to install Java, download and extract the Tomcat source package, set environment paths, start and stop the Tomcat server, and test functionality using HTML, JSP and Servlet files. The server runs on port 8080 by default and can host Java web applications built with Servlets and JSP.
Java is a programming language that compiles code to bytecode that runs on a Java Virtual Machine (JVM). The JVM is an abstraction layer that executes bytecode similarly across operating systems. It includes components like the bytecode verifier, class loader, execution engine, garbage collector, and security manager. The JVM allows Java to be platform independent and "write once, run anywhere".
The document discusses Django, a Python web framework. It began as an internal project at a newspaper to help journalists meet deadlines. Django encourages rapid development, clean design and is database and platform neutral. It features an object relational mapper, automatic admin interface, elegant URLs and templates. Django uses a model-template-view architecture. It provides tools like manage.py to help with development.
This document discusses connecting to and interacting with MySQL databases from PHP. It covers connecting to a MySQL database server, selecting databases, executing SQL statements, working with query results, and inserting, updating and deleting records. Functions covered include mysql_connect(), mysql_query(), mysql_fetch_row(), mysql_affected_rows(), and mysql_info(). The document provides examples of connecting to MySQL, selecting databases, executing queries, and accessing and manipulating data.
Things you should know about Javascript ES5. A programming language that enables you to create dynamically updating content, control multimedia, animate images, and pretty much everything else
This document summarizes the history and benefits of AngularJS. It explains that AngularJS was originally created in 2009 as a side project by Misko Hevery and Adam Abrons to build a tool for both front-end and back-end development. When working on a Google project called Google Feedback, Hevery was able to rewrite 17,000 lines of code into 1,500 lines using his AngularJS framework by taking advantage of its features like separation of concerns, modularity, and reusable components. The document then lists some key benefits of AngularJS like being lightweight, free, and improving structure, quality, organization and maintainability of code.
The document provides an agenda and introduction for a Java training over multiple days. Day 1 will cover an introduction to Java including its history, features, programming paradigm, sample program execution, JVM, data types, objects, classes, variables, and flow control statements. The training will cover key Java concepts like objects, classes, variables, different loops and conditional statements. Assignments are provided to practice the concepts covered.
The document discusses the XML DOM (Document Object Model). It defines the DOM as a standard for accessing and manipulating XML documents through a tree structure representation. The DOM defines all elements in an XML document as nodes that can be traversed and modified. It outlines DOM properties and methods for navigating and manipulating the node tree. Advantages of the DOM include its traversable and modifiable tree structure, while disadvantages include higher resource usage compared to SAX parsing.
- Shell scripting allows users to automate repetitive tasks by writing scripts of shell commands that can be executed automatically. The shell acts as an interface between the user and the operating system kernel, accepting commands and passing them to the kernel for execution. Common shells used for scripting include Bash, C Shell, and Korn Shell. Shell scripts use shell commands, control structures, and functions to perform automated tasks like backups and system monitoring.
Spring I/O 2012: Natural Templating in Spring MVC with ThymeleafThymeleaf
Introduction to the Thymeleaf java XML/XHTML/HTML5 template engine by José Miguel Samper and Daniel Fernández at Spring I/O 2012 Madrid, Feb 17th 2012.
What is Yaml:
Human friendly, cross language, Unicode based data serialization language.
Pronounced in such a way as to rhyme with “camel”
Acronym for
YAML
Ain’t
A language used to convert or represent structured data or objects as a series of characters that can be stored on a disk.
Examples:
CSV – Comma separated values
XML – Extensible markup language
JSON – JavaScript object notation
YAML – YAML ain’t markup language
Markup
Language
This document discusses Node.js functions, modules, and exporting modules. It covers defining functions, parameters, and return values. It also covers the different types of modules in Node.js including core modules, local modules, and third party modules. Finally, it discusses how to export variables, functions, objects, and classes from modules using module.exports.
This document discusses delegates and events in C#. It explains that a delegate is an object that can refer to a method. There are four steps to using delegates: declaration, defining delegate methods, instantiation, and invocation. Delegates can be singlecast or multicast. Events are declared using an event keyword and a delegate type, and allow an object to notify other objects when an event occurs. Multicast delegates can invoke multiple methods by adding delegate instances together using + operator and removing them using - operator.
This document discusses various PHP functions and concepts related to working with databases in PHP, including:
- PHP functions for arrays, calendars, file systems, MySQL, and math
- Using phpMyAdmin to manage MySQL databases
- The GET and POST methods for passing form data
- SQL commands for creating, altering, and manipulating database tables
- Connecting to a MySQL database from PHP using mysql_connect()
It provides code examples for using many of these PHP functions and SQL commands to interact with databases. The document is an overview of key topics for learning PHP database programming.
SQLite is a C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine. It is often used for local/client storage in applications. Key points:
- Created by D. Richard Hipp, it provides a lightweight disk-based database that doesn't require a separate server process and allows accessing the database using SQL queries.
- The entire database is stored in a single cross-platform file and can be as small as 0.5MB, making it suitable for embedded and mobile applications.
- It supports common data types like NULL, INTEGER, REAL, TEXT, and BLOB and is used in standalone apps, local
This document provides an overview of Java servlets technology, including:
1. What Java servlets are and their main purposes and advantages such as portability, power, and integration with server APIs.
2. Key aspects of servlet architecture like the servlet lifecycle, the HttpServletRequest and HttpServletResponse objects, and how different HTTP methods map to servlet methods.
3. Examples of simple servlets that process parameters, maintain a session counter, and examples of deploying servlets in Eclipse IDE.
This document provides an overview of Angular, including:
- Angular is a JavaScript framework used to build client-side applications with HTML. Code is written in TypeScript which compiles to JavaScript.
- Angular enhances HTML with directives, data binding, and dependency injection. It follows an MVC architecture internally.
- Components are the basic building blocks of Angular applications. Modules contain components and services. Services contain reusable business logic.
- The document discusses Angular concepts like modules, components, data binding, services, routing and forms. It provides examples of creating a sample login/welcome application in Angular.
An assembly in .NET contains compiled code and metadata. It can be an EXE or DLL file. When code is compiled, it is translated to IL code and metadata is generated. The IL and metadata are bundled into the assembly file. Assemblies can be private, used by a single app, or shared, used by multiple apps. Shared assemblies are stored in the global assembly cache so they only need to be deployed once. The ILDASM tool allows examining the contents of an assembly.
The document discusses setting up and configuring an Apache Tomcat server. It includes steps to install Java, download and extract the Tomcat source package, set environment paths, start and stop the Tomcat server, and test functionality using HTML, JSP and Servlet files. The server runs on port 8080 by default and can host Java web applications built with Servlets and JSP.
Java is a programming language that compiles code to bytecode that runs on a Java Virtual Machine (JVM). The JVM is an abstraction layer that executes bytecode similarly across operating systems. It includes components like the bytecode verifier, class loader, execution engine, garbage collector, and security manager. The JVM allows Java to be platform independent and "write once, run anywhere".
The document discusses Django, a Python web framework. It began as an internal project at a newspaper to help journalists meet deadlines. Django encourages rapid development, clean design and is database and platform neutral. It features an object relational mapper, automatic admin interface, elegant URLs and templates. Django uses a model-template-view architecture. It provides tools like manage.py to help with development.
There's plenty of material (documentation, blogs, books) out there that'll help
you write a site using Django... but then what? You've still got to test,
deploy, monitor, and tune the site; failure at deployment time means all your
beautiful code is for naught.
This document outlines the spring break blog project assignment for the book A Thousand Splendid Suns. Students will read the book over break and respond to two discussion topics on their blog using the TEAR paragraph format. They will also comment on two other student blogs. The assignment has multiple parts that must be completed by certain due dates, including creating a blog, making two blog posts responding to discussion topics, commenting on two other student posts, and a timed writing assignment upon returning from break. This project incorporates technology and aims to prepare students for college and workplace expectations.
The document outlines a strategy for a health IT blog called HITenlightenment that aims to share concepts, research, ideas, and career information with health informatics professionals. It details how the blog will be integrated with platforms like LinkedIn, SlideShare, and Google Analytics to promote content and track engagement. The results showed the highest conversion rates came from smaller, niche LinkedIn groups and email promotion, demonstrating the importance of targeting specific audiences.
The Python Sevilla meeting of March took place last Wednesday. The talk was given by Pablo Iglesias (Pablo is the Senior Django developer for Emergya in the BeDjango team). During this talk he explained what we know at BedDjango as a “Starter” and some of its characteristics
As a business analyst or strategist, you will learn how to understand the risks of an API project, and the right questions to ask your delivery team. As a technical person, you will learn to communicate the value of an API offering, the urgency of doing it now, and the value it adds to your company’s digital strategy. http://www.softwareag.com/corporate/products/wm/api_management/overview/default.asp
The document provides 12 tips on Django best practices for development, deployment, and external tools. The tips include using virtualenv for isolated environments, managing dependencies with pip and requirements.txt, following a model-template-view framework, keeping views thin and logic in models/forms, and leveraging tools like Fabric, South, Celery, Redis, Sentry, and the Django debug toolbar. The document emphasizes following the Django philosophy and reusing existing apps when possible.
Rami Sayar presented on advanced Django architecture techniques for scaling Django applications in production environments. He discussed load balancing Django across multiple servers using solutions like HAProxy. He also covered caching with Varnish to improve performance, and using Redis or Memcached for caching. Finally, he discussed asynchronous task queues like Celery for processing tasks outside the request-response cycle.
The document discusses security best practices for web applications. It recommends understanding threats like XSS and SQL injection, sanitizing user input, testing code regularly for vulnerabilities, staying up to date on security issues, and using frameworks and secure protocols. It also stresses understanding users and educating them on security basics. Overall, the key message is that developers need to prioritize security, trust no one (including users and tools), and constantly work to protect applications and users.
This presentation is a part of meetup session delivered in the Microsoft User Group - Chandigarh.
In this meetup we looked into how to deploy and manage Virtual Machines in Microsoft Azure cloud.
This was an advanced session and targeted more towards IT Pro audience. Developers were welcome also.
We covered created virtual machines via ARM template and covered with Virtual Machine Scale Sets with a live demo with Autoscale.
Productionizing Machine Learning with a Microservices ArchitectureDatabricks
Deploying machine learning models from training to production requires companies to deal with the complexity of moving workloads through different pipelines and re-writing code from scratch.
Discover the server in your IT ecosystem automatically and understand how various app components interact with each other. Reach us out at appmanager-support@manageengine.com
Learn how to track the user experience of your web applications across multiple geographical locations. Measure and understand the ways customers interact with your software. Discover the basic skills and information needed to get the most out of your synthetic monitoring.
The document discusses various free tools that can be used to monitor IBM WebSphere and its components, including Nagios, WebSphere Performance Tuning Toolkit (PTT), Nmon Visualizer, and Apache mod_status. Nagios is an open source monitoring tool that can monitor WebSphere components like servers, JVM, databases, and more using plugins. WebSphere PTT provides real-time performance monitoring of WebSphere. Nmon Visualizer is useful for visualizing performance data from Linux systems. Mod_status allows monitoring of Apache HTTP servers. Examples and resources are provided for setting up monitoring with these various tools.
Realtime streaming architecture in INFINARIOJozo Kovac
About our experience with realtime analyses on never-ending stream of user events. Discuss Lambda architecture, Kappa, Apache Kafka and our own approach.
"In love with Open Source : Past, Present and Future" : Keynote OSDConf 2014Piyush Kumar
OPEN SOURCE DEVELOPERS CONFERENCE http://osdconf.in/
★ April 26-27th, Noida ★
Keynote Session By Piyush Kumar (Lead of Infrastructure and Website Operations at MakeMyTrip)
This document discusses the challenges of monitoring dynamic containerized infrastructure and provides an overview of how Datadog addresses these challenges. It describes how Datadog collects metrics from containers, applications, and hosts using agents, APIs, and files to provide monitoring of things like CPU usage, memory usage, requests per second and error rates. It also allows tagging and querying metrics for improved visibility.
Opensource approach to design and deployment of Microservices based VNFMichelle Holley
Microservice is gaining increased adoption in the Telco NFV world. It is key to understand the design and deployment methodologies involved in developing Microservice based VNF. This talk provides an opensource practitioner approach to building and deploying a Microservice based VNF and includes the following: - Design patterns, workflow models - Design models for VNF placement, capacity management, scale-in/out and resiliency - Deployment considerations that includes handing of scale and fault tolerant VNF using well known Opensource tools.
About the presenter: Prem Sankar works for Ericsson Opensource Ecosystem team and part of the Opendaylight and OPNFV team in Ericsson. Prem evangelizes SDN and Cloud and has given many sessions and conducted workshops around SDN and ODL. Prem is PTL of ODL COE project and currently driving the Kuberenetes and ODL Integration in Opendaylight community. Prem is a frequent speaker at opensource summits and has presented in Opendaylight, OPNFV and Open networking summits.
Mike Spicer is the lead architect for the IBM Streams team. In his presentation, Mike provides an overview of the many key new features available in IBM Streams V4.1. Simpler development, simpler management, and Spark integration are a few of the capabilities included in IBM Streams V4.1.
This document discusses microservices and the process of setting up a new microservice. It covers topics such as defining the service scope, getting approvals, source control and packaging, running environments, logging and monitoring, and preparing the service for production use. The key aspects of setting up a new microservice include buy-in from management, external design reviews, source control and deployment automation, provisioning compute and storage resources, and integrating the service with monitoring and on-call systems.
Shared Security Responsibility for the Azure CloudAlert Logic
This document discusses shared security responsibility in Azure. It provides an overview of security best practices when using Azure, including understanding the shared responsibility model, implementing network security practices, securing data and access, securely developing code, log management, and vulnerability management. It also describes Alert Logic security solutions that can help monitor Azure environments for threats across the application stack.
Common Sense Performance Indicators in the CloudNick Gerner
This document discusses common performance indicators for monitoring systems in the cloud. It recommends monitoring system characteristics like CPU, memory, disks, and network usage as well as application stack metrics like frontend performance, caching, and database and API usage. Tools like collectd, rrdtool, and drraw can be used to collect, store, and visualize performance data over time to help tune performance, investigate issues, and understand system architectures.
Keeping WebSphere under control with free tools - Wannes & Sharon share some tips and experience on the free tools they use daily to monitor Connections environments using FREE tools
Keeping WebSphere under control with free tools - Wannes & Sharon share some tips and experience on the free tools they use daily to monitor Connections environments using FREE tools
Analyzing the World's Largest Security Data Lake!DataWorks Summit
The document discusses Symantec's CloudFire Analytics platform for analyzing security data at scale. It describes how CloudFire provides Hadoop ecosystem tools on OpenStack virtual machines across 50+ data centers to support security product analytics. Key points covered include analytics services and data, administration and monitoring using tools like Ambari and OpsView, and plans for self-service analytics using dynamic clusters provisioned through CloudBreak integration.
20140708 - Jeremy Edberg: How Netflix Delivers SoftwareDevOps Chicago
Netflix delivers software through fully automated processes and a service-oriented architecture. They hire responsible developers and give them freedom and responsibility. Netflix builds everything to withstand failures through redundancy, automation, and a philosophy of "automate all the things."
The document provides an introduction to the Django web framework, covering topics such as installing Django, creating projects and apps, defining models, using the admin interface, and basic views, URLs, and templates. It includes code examples for creating models, interacting with the database in the Python shell, registering models with the admin, and defining URLconfs and views. The training aims to help developers learn the fundamentals of building applications with Django.
The document discusses best practices and anti-patterns for Django projects. It recommends keeping projects simple by avoiding over-engineering, using application-based modular design, and properly structuring settings files across multiple environments rather than relying on local_settings.py files. It also addresses common issues like import errors caused by PYTHONPATH configuration.
The document discusses creating a strong documentation culture. It notes that everyone reads documentation for various reasons such as first contact, education, support, troubleshooting, and reference. Great documentation has different types of content including tutorials for new users, topic guides for conceptual understanding, reference materials, and troubleshooting guides. Documentation should be written by developers and be "fractal" in its level of detail. While tools are not most important, good documentation tools like Sphinx and Read the Docs can help. The overall aim is to establish a culture where developers recognize the importance of documentation.
This document summarizes the new features in Django 1.2. Key features include support for multiple databases, raw SQL queries, model validation, improved CSRF protection, user messaging, faster tests, and many other improvements and new features. The release timeline includes a beta on January 26, release candidate on March 2, and final release on March 9. Questions can be directed to Jacob Kaplan-Moss by email or Twitter.
The Django web framework follows the model-view-controller (MVC) architectural pattern. Models define the data and logic of an application. Views handle rendering content for users. URLs map requests to views. Templates allow dynamic generation of HTML/content. The admin interface provides a backend for managing content. Additional features include generic views, testing tools, forms, sessions, and authentication support.
Building a web framework: Django's design decisionsJacob Kaplan-Moss
Since its release three years ago Django’s grown by leaps and bounds; it’s now part of a highly successful new generation of web development tools.
However, it hasn’t all been smooth sailing for the Django team. As any Open Source community does, we’ve needed to make a series of tough decisions along the way. These decisions have shaped Django’s internals, public APIs, and community.
Django 1.0 was released in September 2008. This release marks a major turning
point in Django's development; a real maturation of the project. Join the lead
developers of Django as they discuss what's new in Django 1.0, cover the Django
1.1 release (currently scheduled for a few weeks after PyCon), and discuss the
project's future.
This document summarizes the early history and development of Django, an open-source web framework written in Python. It describes how Django originated from dissatisfaction with existing Python web frameworks in the early 2000s. It then outlines Django's initial codebase and features from 2003 to 2005, including early models, an admin interface, and code generation tools. The document concludes by noting major changes and improvements in Django leading up to the 1.0 release in 2008, including changes to the model syntax, documentation, and formal release process.
This document summarizes the evolution of Django's model syntax from its early beginnings in 2004 to the present day trunk version. It shows the creation of database tables and models for a polls application. The model syntax progressed from raw SQL, to a custom Model class, to utilizing Django's built-in Model and fields, and later the introduction of the Meta inner class. It ends by showing how models are now registered with the admin using a separate admin.py file.
Django has grown significantly since version 0.95 with over 2000 commits from 250 contributors. It now supports Unicode and new forms for testing and databrowsing. Many new third party projects now use Django including over 100 projects, AOL.ca, Curse Gaming, FSF, HP/Tabblo, Pownce, and Scripps Newspapers. Django is capable of handling high traffic loads of over 500,000 page views per hour and is well suited for new websites and applications.
Pushing the limits of ePRTC: 100ns holdover for 100 daysAdtran
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
Climate Impact of Software Testing at Nordic Testing DaysKari Kakkonen
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
Full-RAG: A modern architecture for hyper-personalizationZilliz
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-und-domino-lizenzkostenreduzierung-in-der-welt-von-dlau/
DLAU und die Lizenzen nach dem CCB- und CCX-Modell sind für viele in der HCL-Community seit letztem Jahr ein heißes Thema. Als Notes- oder Domino-Kunde haben Sie vielleicht mit unerwartet hohen Benutzerzahlen und Lizenzgebühren zu kämpfen. Sie fragen sich vielleicht, wie diese neue Art der Lizenzierung funktioniert und welchen Nutzen sie Ihnen bringt. Vor allem wollen Sie sicherlich Ihr Budget einhalten und Kosten sparen, wo immer möglich. Das verstehen wir und wir möchten Ihnen dabei helfen!
Wir erklären Ihnen, wie Sie häufige Konfigurationsprobleme lösen können, die dazu führen können, dass mehr Benutzer gezählt werden als nötig, und wie Sie überflüssige oder ungenutzte Konten identifizieren und entfernen können, um Geld zu sparen. Es gibt auch einige Ansätze, die zu unnötigen Ausgaben führen können, z. B. wenn ein Personendokument anstelle eines Mail-Ins für geteilte Mailboxen verwendet wird. Wir zeigen Ihnen solche Fälle und deren Lösungen. Und natürlich erklären wir Ihnen das neue Lizenzmodell.
Nehmen Sie an diesem Webinar teil, bei dem HCL-Ambassador Marc Thomas und Gastredner Franz Walder Ihnen diese neue Welt näherbringen. Es vermittelt Ihnen die Tools und das Know-how, um den Überblick zu bewahren. Sie werden in der Lage sein, Ihre Kosten durch eine optimierte Domino-Konfiguration zu reduzieren und auch in Zukunft gering zu halten.
Diese Themen werden behandelt
- Reduzierung der Lizenzkosten durch Auffinden und Beheben von Fehlkonfigurationen und überflüssigen Konten
- Wie funktionieren CCB- und CCX-Lizenzen wirklich?
- Verstehen des DLAU-Tools und wie man es am besten nutzt
- Tipps für häufige Problembereiche, wie z. B. Team-Postfächer, Funktions-/Testbenutzer usw.
- Praxisbeispiele und Best Practices zum sofortigen Umsetzen
GraphRAG for Life Science to increase LLM accuracyTomaz Bratanic
GraphRAG for life science domain, where you retriever information from biomedical knowledge graphs using LLMs to increase the accuracy and performance of generated answers
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
UiPath Test Automation using UiPath Test Suite series, part 6DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 6. In this session, we will cover Test Automation with generative AI and Open AI.
UiPath Test Automation with generative AI and Open AI webinar offers an in-depth exploration of leveraging cutting-edge technologies for test automation within the UiPath platform. Attendees will delve into the integration of generative AI, a test automation solution, with Open AI advanced natural language processing capabilities.
Throughout the session, participants will discover how this synergy empowers testers to automate repetitive tasks, enhance testing accuracy, and expedite the software testing life cycle. Topics covered include the seamless integration process, practical use cases, and the benefits of harnessing AI-driven automation for UiPath testing initiatives. By attending this webinar, testers, and automation professionals can gain valuable insights into harnessing the power of AI to optimize their test automation workflows within the UiPath ecosystem, ultimately driving efficiency and quality in software development processes.
What will you get from this session?
1. Insights into integrating generative AI.
2. Understanding how this integration enhances test automation within the UiPath platform
3. Practical demonstrations
4. Exploration of real-world use cases illustrating the benefits of AI-driven test automation for UiPath
Topics covered:
What is generative AI
Test Automation with generative AI and Open AI.
UiPath integration with generative AI
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
54. “
I don’t do test driven
development. I do stupidity
driven testing… I wait until
I do something stupid, and
”
then write tests to avoid
doing it again.
— Titus Brown
12
55. Whatever happens, don’t let
your test suite break thinking,
“I’ll go back and fix this later.”
13
71. Unit tests
• “Whitebox” testing
• Verify the small functional units of your
app
• Very fine-grained
17
72. Unit tests
• “Whitebox” testing
• Verify the small functional units of your
app
• Very fine-grained
• Familier to most programmers (JUnit,
NUnit, etc.)
17
73. Unit tests
• “Whitebox” testing
• Verify the small functional units of your
app
• Very fine-grained
• Familier to most programmers (JUnit,
NUnit, etc.)
• Provided in Python by unittest
17
84. Doctests
• Easy to write & read.
• Produces self-documenting code.
• Great for cases that only use assertEquals.
20
85. Doctests
• Easy to write & read.
• Produces self-documenting code.
• Great for cases that only use assertEquals.
• Somewhere between unit tests and
functional tests.
20
86. Doctests
• Easy to write & read.
• Produces self-documenting code.
• Great for cases that only use assertEquals.
• Somewhere between unit tests and
functional tests.
• Difficult to debug.
20
87. Doctests
• Easy to write & read.
• Produces self-documenting code.
• Great for cases that only use assertEquals.
• Somewhere between unit tests and
functional tests.
• Difficult to debug.
• Don’t always provide useful test failures.
20
88. class Choices(object):
"""
Easy declarative "choices" tool::
>>> STATUSES = Choices("Live", "Draft")
# Acts like a choices list:
>>> list(STATUSES)
[(1, 'Live'), (2, 'Draft')]
# Easily convert from code to verbose:
>>> STATUSES.verbose(1)
'Live'
# ... and vice versa:
>>> STATUSES.code("Draft")
2
"""
…
21
93. Functional tests
• a.k.a “Behavior Driven Development.”
• “Blackbox,” holistic testing.
• All the hardcore TDD folks look down on
functional tests.
23
94. Functional tests
• a.k.a “Behavior Driven Development.”
• “Blackbox,” holistic testing.
• All the hardcore TDD folks look down on
functional tests.
• But they keep your boss happy.
23
95. Functional tests
• a.k.a “Behavior Driven Development.”
• “Blackbox,” holistic testing.
• All the hardcore TDD folks look down on
functional tests.
• But they keep your boss happy.
• Easy to find problems; harder to find the
actual bug.
23
103. django.test.Client
• Test the whole request path without
running a web server.
• Responses provide extra information
about templates and their contexts.
25
104. class StoryAddViewTests(TestCase):
fixtures = ['authtestdata', 'newsbudget_test_data']
urls = 'newsbudget.urls'
def test_story_add_get(self):
r = self.client.get('/budget/stories/add/')
self.assertEqual(r.status_code, 200)
…
def test_story_add_post(self):
data = {
'title': 'Hungry cat is hungry',
'date': '2009-01-01',
}
r = self.client.post('/budget/stories/add/', data)
self.assertEqual(r.status_code, 302)
…
26
107. Web browser testing
• The ultimate in functional testing for
web applications.
• Run test in a web browser.
27
108. Web browser testing
• The ultimate in functional testing for
web applications.
• Run test in a web browser.
• Can verify JavaScript, AJAX; even CSS.
27
109. Web browser testing
• The ultimate in functional testing for
web applications.
• Run test in a web browser.
• Can verify JavaScript, AJAX; even CSS.
• Test your site across supported browsers.
27
127. Designing for reuse
• Do one thing, and do it well.
• Don’t be afraid of multiple apps.
33
128. Designing for reuse
• Do one thing, and do it well.
• Don’t be afraid of multiple apps.
• Write for flexibility.
33
129. Designing for reuse
• Do one thing, and do it well.
• Don’t be afraid of multiple apps.
• Write for flexibility.
• Build to distribute.
33
130. Designing for reuse
• Do one thing, and do it well.
• Don’t be afraid of multiple apps.
• Write for flexibility.
• Build to distribute.
• Extend carefully.
33
137. Good focus
• “Handle storage of users and
authentication of their identities.”
37
138. Good focus
• “Handle storage of users and
authentication of their identities.”
• “Allow content to be tagged, del.icio.us
style, with querying by tags.”
37
139. Good focus
• “Handle storage of users and
authentication of their identities.”
• “Allow content to be tagged, del.icio.us
style, with querying by tags.”
• “Handle entries in a weblog.”
37
141. Bad focus
• “Handle entries in a weblog, and users
who post them, and their authentication,
and tagging and categorization, and some
flat pages for static content, and...”
38
149. Small is good
• Many great Django apps are very small.
• Even a lot of “simple” Django sites
commonly have a dozen or more
applications in INSTALLED_APPS.
40
150. Small is good
• Many great Django apps are very small.
• Even a lot of “simple” Django sites
commonly have a dozen or more
applications in INSTALLED_APPS.
• If you’ve got a complex site and a short
application list, something’s probably wrong.
40
159. The monolith anti-pattern
• The “application” is the whole site.
• Re-use? YAGNI.
• Plugins that hook into the “main” application.
43
160. The monolith anti-pattern
• The “application” is the whole site.
• Re-use? YAGNI.
• Plugins that hook into the “main” application.
• Heavy use of middleware-like concepts.
43
164. The Django mindset
• Application: some bit of functionality.
• Site: several applications.
45
165. The Django mindset
• Application: some bit of functionality.
• Site: several applications.
• Spin off new “apps” liberally.
45
166. The Django mindset
• Application: some bit of functionality.
• Site: several applications.
• Spin off new “apps” liberally.
• Develop a suite of apps ready for when
they’re needed.
45
169. Django encourages this
• INSTALLED_APPS
• Applications are just Python packages,
not some Django-specific “app” or
“plugin.”
46
170. Django encourages this
• INSTALLED_APPS
• Applications are just Python packages,
not some Django-specific “app” or
“plugin.”
• Abstractions like django.contrib.sites
make you think about this as you develop.
46
172. Spin off a new app?
• Is this feature unrelated to the app’s focus?
47
173. Spin off a new app?
• Is this feature unrelated to the app’s focus?
• Is it orthogonal to the rest of the app?
47
174. Spin off a new app?
• Is this feature unrelated to the app’s focus?
• Is it orthogonal to the rest of the app?
• Will I need similar functionality again?
47
180. But… what about…
• Site A wants a contact form that just
collects a message.
52
181. But… what about…
• Site A wants a contact form that just
collects a message.
• Site B’s marketing department wants a
bunch of info.
52
182. But… what about…
• Site A wants a contact form that just
collects a message.
• Site B’s marketing department wants a
bunch of info.
• Site C wants to use Akismet to filter
automated spam.
52
198. Form processing
• You want to redirect after successful
submission.
• Supply a default URL.
58
199. Form processing
• You want to redirect after successful
submission.
• Supply a default URL.
• (Preferably by using reverse resolution).
58
200. Form processing
• You want to redirect after successful
submission.
• Supply a default URL.
• (Preferably by using reverse resolution).
• Let users override the default.
58
201. def edit_entry(request, entry_id):
form = EntryForm(request.POST or None)
if form.is_valid():
form.save()
return redirect('entry_detail', entry_id)
return render_to_response('entry/form.html', {…})
59
202. def edit_entry(request, entry_id,
form_class=EntryForm,
template_name='entry/form.html',
post_save_redirect=None):
form = form_class(request.POST or None)
if form.is_valid():
form.save()
if post_save_redirect:
return redirect(post_save_redirect)
else:
return redirect('entry_detail', entry_id)
return render_to_response([template_name, 'entry/form.html'], {…})
60
226. Where apps really live
• Single module directly on Python path
(registration, tagging, etc.).
70
227. Where apps really live
• Single module directly on Python path
(registration, tagging, etc.).
• Related modules under a top-level
package (ellington.events,
ellington.podcasts, etc.)
70
228. Where apps really live
• Single module directly on Python path
(registration, tagging, etc.).
• Related modules under a top-level
package (ellington.events,
ellington.podcasts, etc.)
• No projects (ellington.settings doesn’t
exist).
70
231. Want to distribute?
• Build a package with distutils/setuptools.
• Put it on PyPI (or a private package
server).
71
232. Want to distribute?
• Build a package with distutils/setuptools.
• Put it on PyPI (or a private package
server).
• Now it works with easy_install, pip,
buildout, …
71
235. General best practices
• Establish dependancy rules.
• Establish a minimum Python version
(suggestion: Python 2.5).
72
236. General best practices
• Establish dependancy rules.
• Establish a minimum Python version
(suggestion: Python 2.5).
• Establish a minimum Django version
(suggestion: Django 1.0).
72
237. General best practices
• Establish dependancy rules.
• Establish a minimum Python version
(suggestion: Python 2.5).
• Establish a minimum Django version
(suggestion: Django 1.0).
• Test frequently against new versions
of dependancies.
72
242. Don’t touch!
• Good applications are extensible
without patching.
• Take advantage of every extensibility point
an application gives you.
75
243. Don’t touch!
• Good applications are extensible
without patching.
• Take advantage of every extensibility point
an application gives you.
• You may end up doing something that
deserves a new application anyway.
75
257. Other tricks
• Signals lets you fire off customized
behavior when certain events happen.
81
258. Other tricks
• Signals lets you fire off customized
behavior when certain events happen.
• Middleware offers full control over
request/response handling.
81
259. Other tricks
• Signals lets you fire off customized
behavior when certain events happen.
• Middleware offers full control over
request/response handling.
• Context processors can make additional
information available if a view doesn’t.
81
260. If you must make
changes to
external code…
82
262. Keep changes to a minimum
• If possible, instead of adding a feature,
add extensibility.
83
263. Keep changes to a minimum
• If possible, instead of adding a feature,
add extensibility.
• Keep as much changed code as you can
out of the original app.
83
266. Stay up-to-date
• Don’t want to get out of sync with the
original version of the code!
• You might miss bugfixes.
84
267. Stay up-to-date
• Don’t want to get out of sync with the
original version of the code!
• You might miss bugfixes.
• You might even miss the feature you
needed.
84
269. Use a good VCS
• Subversion vendor branches don’t cut it.
85
270. Use a good VCS
• Subversion vendor branches don’t cut it.
• DVCSes are perfect for this:
85
271. Use a good VCS
• Subversion vendor branches don’t cut it.
• DVCSes are perfect for this:
• Mercurial queues.
85
272. Use a good VCS
• Subversion vendor branches don’t cut it.
• DVCSes are perfect for this:
• Mercurial queues.
• Git rebasing.
85
273. Use a good VCS
• Subversion vendor branches don’t cut it.
• DVCSes are perfect for this:
• Mercurial queues.
• Git rebasing.
• At the very least, maintain a patch queue
by hand.
85
275. Be a good citizen
• If you change someone else’s code, let
them know.
86
276. Be a good citizen
• If you change someone else’s code, let
them know.
• Maybe they’ll merge your changes in and
you won’t have to fork anymore.
86
283. Deployment should...
• Be automated.
• Automatically manage dependencies.
• Be isolated.
• Be repeatable.
89
284. Deployment should...
• Be automated.
• Automatically manage dependencies.
• Be isolated.
• Be repeatable.
• Be identical in staging and in production.
89
285. Deployment should...
• Be automated.
• Automatically manage dependencies.
• Be isolated.
• Be repeatable.
• Be identical in staging and in production.
• Work the same for everyone.
89
294. Dependancy management
• The Python ecosystem rocks!
• Python package management doesn’t.
• Installing packages — and dependancies
— correctly is a lot harder than it should be;
most defaults are wrong.
91
295. Dependancy management
• The Python ecosystem rocks!
• Python package management doesn’t.
• Installing packages — and dependancies
— correctly is a lot harder than it should be;
most defaults are wrong.
• Here be dragons.
91
298. Vendor packages
• APT, Yum, …
• The good: familiar tools; stability; handles
dependancies not on PyPI.
92
299. Vendor packages
• APT, Yum, …
• The good: familiar tools; stability; handles
dependancies not on PyPI.
• The bad: small selection; not (very)
portable; hard to supply user packages.
92
300. Vendor packages
• APT, Yum, …
• The good: familiar tools; stability; handles
dependancies not on PyPI.
• The bad: small selection; not (very)
portable; hard to supply user packages.
• The ugly: installs packages system-wide.
92
307. pip
http://pip.openplans.org/
• “Pip Installs Packages”
• The good: Just Works™; handles non-
PyPI packages (including direct from
SCM); repeatable dependancies;
integrates with virtualenv for isolation.
94
308. pip
http://pip.openplans.org/
• “Pip Installs Packages”
• The good: Just Works™; handles non-
PyPI packages (including direct from
SCM); repeatable dependancies;
integrates with virtualenv for isolation.
• The bad: still young; not yet bundled.
94
309. pip
http://pip.openplans.org/
• “Pip Installs Packages”
• The good: Just Works™; handles non-
PyPI packages (including direct from
SCM); repeatable dependancies;
integrates with virtualenv for isolation.
• The bad: still young; not yet bundled.
• The ugly: haven’t found it yet.
94
311. zc.buildout
http://buildout.org/
• The good: incredibly flexible; handles any
sort of dependancy; repeatable builds;
reusable “recipes;” good ecosystem;
handles isolation, too.
95
312. zc.buildout
http://buildout.org/
• The good: incredibly flexible; handles any
sort of dependancy; repeatable builds;
reusable “recipes;” good ecosystem;
handles isolation, too.
• The bad: often cryptic, INI-style
configuration file; confusing duplication of
recipes; sometimes too flexible.
95
313. zc.buildout
http://buildout.org/
• The good: incredibly flexible; handles any
sort of dependancy; repeatable builds;
reusable “recipes;” good ecosystem;
handles isolation, too.
• The bad: often cryptic, INI-style
configuration file; confusing duplication of
recipes; sometimes too flexible.
• The ugly: nearly completely undocumented.
95
317. Package isolation
• Why?
• Site A requires Foo v1.0; site B requires
Foo v2.0.
• You need to develop against multiple
versions of dependancies.
96
325. Why automate?
• “I can’t push this fix to the servers until
Alex gets back from lunch.”
98
326. Why automate?
• “I can’t push this fix to the servers until
Alex gets back from lunch.”
• “Sorry, I can’t fix that. I’m new here.”
98
327. Why automate?
• “I can’t push this fix to the servers until
Alex gets back from lunch.”
• “Sorry, I can’t fix that. I’m new here.”
• “Oops, I just made the wrong version of
our site live.”
98
328. Why automate?
• “I can’t push this fix to the servers until
Alex gets back from lunch.”
• “Sorry, I can’t fix that. I’m new here.”
• “Oops, I just made the wrong version of
our site live.”
• “It’s broken! What’d you do!?”
98
335. Capistrano
http://capify.org/
• The good: lots of features; good
documentation; active community.
• The bad: stale development; very
“opinionated” and Rails-oriented.
100
354. import os, sys
# Add to PYTHONPATH whatever you need
sys.path.append('/usr/local/django')
# Set DJANGO_SETTINGS_MODULE
os.environ['DJANGO_SETTINGS_MODULE'] = 'mysite.settings'
# Create the application for mod_wsgi
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()
110
370. Connection middleware
• Proxy between web and database layers
• Most implement hot fallover and
connection pooling
119
371. Connection middleware
• Proxy between web and database layers
• Most implement hot fallover and
connection pooling
• Some also provide replication, load
balancing, parallel queries, connection
limiting, &c
119
372. Connection middleware
• Proxy between web and database layers
• Most implement hot fallover and
connection pooling
• Some also provide replication, load
balancing, parallel queries, connection
limiting, &c
• DATABASE_HOST = '127.0.0.1'
119
405. CREATE POOL mypool
POOL mypool ADD 10.0.0.100
POOL mypool ADD 10.0.0.101
CREATE SERVICE mysite
SET listen = my.public.ip
SET role = reverse_proxy
SET pool = mypool
SET verify_backend = on
SET buffer_size = 120k
ENABLE mysite
130
407. proxy proxy proxy media media
load balancing cluster media server cluster
django django django cache cache
web server cluster cache cluster
database database database
database server cluster
132
409. BALANCE = None
def balance_sheet(request):
global BALANCE
if not BALANCE:
bank = Bank.objects.get(...)
BALANCE = bank.total_balance()
...
134
410. BALANCE = None
def balance_sheet(request):
global BALANCE
if not BALANCE:
bank = Bank.objects.get(...)
BALANCE = bank.total_balance()
...
FAIL 134
419. Further reading
• Cal Henderson, Building Scalable Web Sites
• John Allspaw, The Art of Capacity Planning
139
420. Further reading
• Cal Henderson, Building Scalable Web Sites
• John Allspaw, The Art of Capacity Planning
• http://kitchensoap.com/
139
421. Further reading
• Cal Henderson, Building Scalable Web Sites
• John Allspaw, The Art of Capacity Planning
• http://kitchensoap.com/
• http://highscalability.com/
139
425. Goals
• When the site goes down, know it immediately.
• Automatically handle common sources of
downtime.
141
Editor's Notes
Oh hai. I’m Jacob Kaplan-Moss; here’s a few ways to get in touch with me.
I wear quite a few hats. Today, I’m wearing two: I’m one of the lead developers of Django; I’m a partner at `Revolution Systems`__, a consulting business specializing in, well, the stuff I’m about to talk about.
Just a brief shameless plug: my day job is as a consultant working in and around these issues. I get to come talk about this stuff publicly because of this gig, so If you need info specific to your situation please consider giving us a call!
Credit where credit is due: I first gave this talk at PyCon 2009 with the help of `James Bennett`__, so much of my thinking and some of the content comes from James.
__ http://b-list.org/
This is the main theme of this tutorial: you’ve written a Django site...
... and you’ve barely started.
Writing the app is the easy part; what comes next is seriously complicated.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
Here’s just one list (Leonard Lin’s) of what you might need to think about *after* writing your app; I could easily add another dozen more things to this list. Luckily, not every site needs *all* of this... but any site of any size will need to understand at last some of this stuff, and bigger deployments will need to worry about all of it.
Obviously this is far too much to cover even in a long tutorial, so we’ll pick and choose; the point is that writing the app is usually the easy part. Today we’re talking about what comes next.
So here’s the bare minimum you’ll need to think about:
* You need to test your sites. Without tests, you can’t move forward without downtime.
* You need to write your code in a way that makes deployment possible — and easy.
* You need to use deployment tools that automate the repetitive bits and keep you from shooting yourself in the foot.
* You need a production environment that scales with your traffic.
* You need to watch your sites in action so that you know what’s up.
* When things go slow you need to fix it.
So here’s the bare minimum you’ll need to think about:
* You need to test your sites. Without tests, you can’t move forward without downtime.
* You need to write your code in a way that makes deployment possible — and easy.
* You need to use deployment tools that automate the repetitive bits and keep you from shooting yourself in the foot.
* You need a production environment that scales with your traffic.
* You need to watch your sites in action so that you know what’s up.
* When things go slow you need to fix it.
So here’s the bare minimum you’ll need to think about:
* You need to test your sites. Without tests, you can’t move forward without downtime.
* You need to write your code in a way that makes deployment possible — and easy.
* You need to use deployment tools that automate the repetitive bits and keep you from shooting yourself in the foot.
* You need a production environment that scales with your traffic.
* You need to watch your sites in action so that you know what’s up.
* When things go slow you need to fix it.
So here’s the bare minimum you’ll need to think about:
* You need to test your sites. Without tests, you can’t move forward without downtime.
* You need to write your code in a way that makes deployment possible — and easy.
* You need to use deployment tools that automate the repetitive bits and keep you from shooting yourself in the foot.
* You need a production environment that scales with your traffic.
* You need to watch your sites in action so that you know what’s up.
* When things go slow you need to fix it.
So here’s the bare minimum you’ll need to think about:
* You need to test your sites. Without tests, you can’t move forward without downtime.
* You need to write your code in a way that makes deployment possible — and easy.
* You need to use deployment tools that automate the repetitive bits and keep you from shooting yourself in the foot.
* You need a production environment that scales with your traffic.
* You need to watch your sites in action so that you know what’s up.
* When things go slow you need to fix it.
So here’s the bare minimum you’ll need to think about:
* You need to test your sites. Without tests, you can’t move forward without downtime.
* You need to write your code in a way that makes deployment possible — and easy.
* You need to use deployment tools that automate the repetitive bits and keep you from shooting yourself in the foot.
* You need a production environment that scales with your traffic.
* You need to watch your sites in action so that you know what’s up.
* When things go slow you need to fix it.
So now you’ve got a working app, but how do you *know* that it works? Sure, you could just run the site and click around, but that guarantees nothing. The difference between stable and unstable code is often the quality of the tests.
The “fear” that Beck is talking about here is the fear of not knowing if your new site will run or not. Testing, while often boring, relives you of that fear.
`Test Driven Development`__ by Kent Beck is the bible of TDD. Beck requires that you only add new code to your project after an existing test fails. This means writing tests before writing any new code. It can be rewarding -- particularly if you’re pair programming so you can keep each other honest. Unfortunately, it’s also simply not practical for most developers.
__ http://www.amazon.com/dp/0321146530/
This is the pragmatic approach to testing: write tests when you need them. If you need to chase down a bug, write a test to trigger the bug, then when the test passes you know the bug is licked.
Yes, this leaves you with less than perfect coverage.
I’m speaking from experience here. Once you commit with even a *single* breaking test, finding the time to clean up is an uphill battle. Knowing the suite fails discourages you from even running the tests at all, and thus the quality continues to decline.
I tend to think of this as a continuum of testing; another way of thinking about this is a continuum between internal/external, or whitebox/blackbox.
I tend to think of this as a continuum of testing; another way of thinking about this is a continuum between internal/external, or whitebox/blackbox.
I tend to think of this as a continuum of testing; another way of thinking about this is a continuum between internal/external, or whitebox/blackbox.
I tend to think of this as a continuum of testing; another way of thinking about this is a continuum between internal/external, or whitebox/blackbox.
Testing web applications is *hard*. Anything with a persistent state -- i.e. a database -- and network communications -- HTTP -- is a real pain to test.
Ruby on Rails really changed the game, though. When it shipped a set of tools that took most of the pain out of automating web tests, it galvenized developers to compete.
Django’s since come out with our own spin on this set of tools. I’m only going to cover doctests in this intro tutorial, so a brief overview of the other tools is in order:
* Unit tests: Django can run tests using Python’s standard `unittest` framework, which is based on Java’s JUnit. Perfect for more formal unit tests like you’d see in Java/C#.
* Fixtures: fixtures are a way of loading preset data into the database for each test, thus letting you test against “real” data.
* The test client: this lets you “fake” a request to your views and inspect the returned response, template, and context.
* Email capture: the test suite will intercept sent email so you can test logic involving email.
Testing web applications is *hard*. Anything with a persistent state -- i.e. a database -- and network communications -- HTTP -- is a real pain to test.
Ruby on Rails really changed the game, though. When it shipped a set of tools that took most of the pain out of automating web tests, it galvenized developers to compete.
Django’s since come out with our own spin on this set of tools. I’m only going to cover doctests in this intro tutorial, so a brief overview of the other tools is in order:
* Unit tests: Django can run tests using Python’s standard `unittest` framework, which is based on Java’s JUnit. Perfect for more formal unit tests like you’d see in Java/C#.
* Fixtures: fixtures are a way of loading preset data into the database for each test, thus letting you test against “real” data.
* The test client: this lets you “fake” a request to your views and inspect the returned response, template, and context.
* Email capture: the test suite will intercept sent email so you can test logic involving email.
Testing web applications is *hard*. Anything with a persistent state -- i.e. a database -- and network communications -- HTTP -- is a real pain to test.
Ruby on Rails really changed the game, though. When it shipped a set of tools that took most of the pain out of automating web tests, it galvenized developers to compete.
Django’s since come out with our own spin on this set of tools. I’m only going to cover doctests in this intro tutorial, so a brief overview of the other tools is in order:
* Unit tests: Django can run tests using Python’s standard `unittest` framework, which is based on Java’s JUnit. Perfect for more formal unit tests like you’d see in Java/C#.
* Fixtures: fixtures are a way of loading preset data into the database for each test, thus letting you test against “real” data.
* The test client: this lets you “fake” a request to your views and inspect the returned response, template, and context.
* Email capture: the test suite will intercept sent email so you can test logic involving email.
Testing web applications is *hard*. Anything with a persistent state -- i.e. a database -- and network communications -- HTTP -- is a real pain to test.
Ruby on Rails really changed the game, though. When it shipped a set of tools that took most of the pain out of automating web tests, it galvenized developers to compete.
Django’s since come out with our own spin on this set of tools. I’m only going to cover doctests in this intro tutorial, so a brief overview of the other tools is in order:
* Unit tests: Django can run tests using Python’s standard `unittest` framework, which is based on Java’s JUnit. Perfect for more formal unit tests like you’d see in Java/C#.
* Fixtures: fixtures are a way of loading preset data into the database for each test, thus letting you test against “real” data.
* The test client: this lets you “fake” a request to your views and inspect the returned response, template, and context.
* Email capture: the test suite will intercept sent email so you can test logic involving email.
Testing web applications is *hard*. Anything with a persistent state -- i.e. a database -- and network communications -- HTTP -- is a real pain to test.
Ruby on Rails really changed the game, though. When it shipped a set of tools that took most of the pain out of automating web tests, it galvenized developers to compete.
Django’s since come out with our own spin on this set of tools. I’m only going to cover doctests in this intro tutorial, so a brief overview of the other tools is in order:
* Unit tests: Django can run tests using Python’s standard `unittest` framework, which is based on Java’s JUnit. Perfect for more formal unit tests like you’d see in Java/C#.
* Fixtures: fixtures are a way of loading preset data into the database for each test, thus letting you test against “real” data.
* The test client: this lets you “fake” a request to your views and inspect the returned response, template, and context.
* Email capture: the test suite will intercept sent email so you can test logic involving email.