Wednesday, August 30, 2017

Daily bread 08/30/2017

    • make their way to
    • is made up of
    • re-enacts
  • tags: chocolate

  • tags: software-development-101

    • developer
    • write code against a database
    • database administrator
    • access to the production database.
    • DBA
    • operations manager
    • spun up a virtual machine
    • table and index schema
    • syntactically valid test data
    • configuration file and scripts
    • agile
    • devops
    • devops offers a big box of tools that automate the way around requests
    • These tools can be divided into sets that support each step in the software development lifecycle, from coding to integration to deployment to monitoring to bug reporting.
    • For a developer, working life revolves around a development environment.
    • Existing code lives in a repository, such as Git or Team Foundation Server (TFS),
    • developer’s first task every day (after the daily stand-up meeting that agile organizations hold first thing) is to check out or clone all of the code of interest from the shared repository
    • merging, integrating, and testing
    • defect manager (be it Bugzilla, JIRA, Redmine, TFS, or any other tracker
    • “tickets” (bug reports or task assignments)
    • IDE such as Eclipse or Visual Studio often has a window into the defect manager
    • The developer will either continue yesterday’s project, or shelve that and handle a higher-priority ticket, if there is one.
    • IDEs often integrate tightly with repositories
    • a command-line console open for check-ins and check-outs.
    • bug trackers often integrate with source code repositories.

    • The code editor is usually the core component of an IDE
    • introduce merge conflicts
    • Developers’ build tools
 depend on the programming language(s) they’re writing in
    • compiled languages,
    • the syntax of the language,
    • code editor
    • flag errors in the background during coding and highlight the syntax with colors
    • already-defined variable
    • When developers write and test code, they often spend the majority of the day running a debugger.
    • in an organization that has implemented devops, they often have the luxury of debugging in a virtualized environment that faithfully reflects the production environment.
    • use stub code to represent server actions or have local databases stand in for remote databases.
    • help developers run their unit tests and regression tests easily and on a regular basis.
    • Test runners
    • the testing framework integrates with the IDE and any local repository,
    • check-in,
    • The developer’s tests should flow into the code integration environment through the shared repository, along with the source code that the developer has debugged and tested.
    • Code integration tools take the code in a shared repository, build it, test 
it, and report on the results.
    • continuous integration server
    • tie into automated build tools, automated test runners, automated reporting via email and defect managers, and actions on the repository.
    • Jenkins,
    • implement continuous integration for every code push
    • a delay is introduced after a code push so that multiple pushes can be combined into the next build.
    • incremental build time is small
    • run nightly “clean” builds and tests, often on freshly provisioned test environments.
    • Deployment tools and environments
    • continuous integration server
    • deploy builds
    • deployment and configuration management tools
    • vary depending on the run-time platform and the additional infrastructure.
    • some configuration management tools – such as Ansible, Chef, Puppet, Salt, and Vagrant – work across a wide range of platforms by using widely supported languages. Ansible and Salt are Python-based systems; Chef, Puppet, and Vagrant are Ruby-based.
    • Software containers such as Docker
    • In the grand scheme of a software lifecycle, each feature moves from design to development to testing to staging to production, while bug reports feed back to the developers for triage and fixes at each stage.
    • what needs to be automated is the release process management; in addition, teams need to automate their tests, bug tracking, building, packaging, configuration, and promotion processes.
    • Runtime monitoring tools

    • Acceptance testing
    • performance testing
    • load testing
    • application performance
    • a spike in usage, a memory leak that manifests over time, a bad spot on a disk, an overloaded server, or an ill-considered database index
    • Application performance monitoring is intended to continually create metrics for the key performance indicators that matter to your application.
    • DDCM (deep dive component monitoring) agents
    • Bug reporting and reproduction tools
    • defect managers
    • reported defect will be accompanied by a detailed description, a root cause, a script to reproduce the problem, and it will be assigned to the developer most familiar with the relevant code.
    • remotely entering and running diagnostics on the user’s machine.

    • Sometimes such problems will not reproduce on a developer’s machine. One common reason for this is that the development box is too fast and has too much memory to show the problem. Another possibility is that the developer has a library installed that the user lacks. And a third is that the user has another application installed that interferes with yours.
    • user’s runtime environment,
    • create a similar runtime environment in a VM
    • configuration management tools
    • test VM may run locally on the developer’s machine, on a server, or on an IaaS cloud.
    • Vagrant
    • it’s useful to have a scaled-down copy of the production application running in a PaaS, so that changes never propagate to the production environment.
    • a change set added to the code repository,
    • regression tested
    • all acceptance tests will be run
    • release manager or customer service manager
    • propagate the change to production or schedule it for later integration
    • give the user a patch or an operational work-around.
    • modern agile application lifecycle
    • after which an application version is released from development to testing.
    • sprints – typically one to two weeks
    • a given build’s climb from development to testing to staging to production.
    • lifecycle of a story card or application feature.
    • bug reports and fixes.
    • easily bog down at any stage.
    • purpose of devops is to see that the routine things, such as bringing up a clean test database or promoting a build, are quick and easy, so that the developers can concentrate on building actual features and fixing real bugs.

Posted from Diigo. The rest of my favorite links are here.

Monday, August 21, 2017

Daily bread 08/21/2017

Posted from Diigo. The rest of my favorite links are here.