Skip to main content

Home/ Arquitectura?/ Group items tagged software-architecture

Rss Feed Group items tagged

Pablo Lalloni

How the DevOps revolution informs software architecture - O'Reilly Radar - 0 views

  •  
    "Ford noted the growing relationship between software architecture and DevOps. The interdependence of the two disciplines is evident within Ford's company: "One of the things that we're really adamant about now," he said, "is that someone from DevOps and operations should be a full-time member of a software development team … you cut way down on churn and other sorts of useless engineering activities.""
Pablo Lalloni

Microservices Tips and Tricks - 1 views

  •  
    "Microservices based architectures are not new but are suddenly in the spotlight due to their powerful and sophisticated practices enabling streamlined application development and deployment. However, transitioning from a monolithic approach to a microservices-based architecture requires not only technical expertise, but organizational buy-in as well. In a recent ActiveState webinar, John Wetherill and Phil Whelan discussed a number of tips and tricks to help companies transition to and get the most out a microservices-based approach."
Pablo Lalloni

Simple event sourcing - introduction (part 1) » Zilverblog - 0 views

  •  
    "This is the first part of a series on building an event sourced application. We'll build a simple blogging application (inspired by the Ruby on Rails "Getting Started" tutorial), so the domain should be familiar. This allows us to focus on implementing a memory image based architecture using event sourcing. Another goal is to show that this kind of architecture is not more complex (and arguably, simpler) than those implemented by traditional database centered applications."
munyeco

The Twelve-Factor App - 2 views

shared by munyeco on 20 Jul 14 - No Cached
  • The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, offering maximum portability between execution environments; Are suitable for deployment on modern cloud platforms, obviating the need for servers and systems administration; Minimize divergence between development and production, enabling continuous deployment for maximum agility; And can scale up without significant changes to tooling, architecture, or development practices. The twelve-factor methodology can be applied to apps written in any programming language, and which use any combination of backing services (database, queue, memory cache, etc).
  •  
    "Introduction In the modern era, software is commonly delivered as a service: called web apps, or software-as-a-service. The twelve-factor app is a methodology for building software-as-a-service apps that: Use declarative formats for setup automation, to minimize time and cost for new developers joining the project; Have a clean contract with the underlying operating system, offering maximum portability between execution environments; Are suitable for deployment on modern cloud platforms, obviating the need for servers and systems administration; Minimize divergence between development and production, enabling continuous deployment for maximum agility; And can scale up without significant changes to tooling, architecture, or development practices. The twelve-factor methodology can be applied to apps written in any programming language, and which use any combination of backing services (database, queue, memory cache, etc). Background The contributors to this document have been directly involved in the development and deployment of hundreds of apps, and indirectly witnessed the development, operation, and scaling of hundreds of thousands of apps via our work on the Heroku platform. This document synthesizes all of our experience and observations on a wide variety of software-as-a-service apps in the wild. It is a triangulation on ideal practices for app development, paying particular attention to the dynamics of the organic growth of an app over time, the dynamics of collaboration between developers working on the app's codebase, and avoiding the cost of software erosion. Our motivation is to raise awareness of some systemic problems we've seen in modern application development, to provide a shared vocabulary for discussing those problems, and to offer a set of broad conceptual solutions to those problems with accompanying terminology. The format is inspired by Martin Fowler's books Patterns of Enterprise Application Architecture and Refactoring. Who should
  •  
    Bueno. Eso. Compartí el que me di cuenta que puso antes Pablo en vez del original por error, pero la idea entre ambos, si la obviedad es tolerable, es idéntica :) Está muy bien estructurado en cuanto que cada factor depende de los demás a la vez que los promueve. Permite un enfoque general que incluye prácticas de arquitectura - y de armado cotidiano de productos - que posibilitan llegar donde yo entiendo - según me voy enterando - que es el lugar a donde llegar. Sin embargo, creo que ni éste departamento en sus sistemas más nuevos cumple todos y cada uno de aquellos factores. Esto, lejos de ser una crítica, es una invitación para que revisemos si es el único método posible - cosa improbabilísima - o el mejor método - también bastante improblable - a seguir. Lo que sí sostengo como un absoluto - quien no lo haría - es que es un método practicable. Mi aporte mínimo es defenderlo como uno bueno.
Pablo Lalloni

Introduction - 0 views

  •  
    "MICROSERVICES ARCHITECTURE GUIDE"
Pablo Lalloni

Microservices and PaaS - Part I | ActiveState - 0 views

  • Instead of building software that resembles our existing organizations, we should figure out how we want our software to look, then build the organization around that. Or reorganize it if it's already in place.
    • Pablo Lalloni
       
      Las implicancias de esta idea en nuestra organización...
  • When deploying a new feature, enhancing or fixing an existing capability, or deploying an experimental line of code, the previous code remains available and accessible. New code is deployed alongside the old code, with mechanisms in place to instantly route to one or another version.
  • Importantly, the old code is not replaced, but remains part of the system, and is kept running. If, as is often the case, the widespread introduction of the new feature results in unforeseen consequences, the feature flag can be toggled off, and the old version is instantly used instead.
  • ...13 more annotations...
  • In a microservices architecture, an application is comprised of a number of small, independent composable services that interact by way of an external published protocol, such as REST, or a messaging service.
  • Each service is focused on an individual targeted business capability, and thus its scope is minimized. For functionality out of scope, the microservice calls out to other microservices via the published protocol.
  • Small independent microservices can be built using the technology best suited for their requirements. No longer does every application component need to be built on a common company-mandated language and framework such as Java/Spring or Ruby on Rails.
  • Similarly, there's no reason to standardize on a single persistence layer across an entire application. Some microservices might best be served by Redis, others by Oracle.
  • Each microservice can be updated independently, no longer requiring the entire application to be redeployed.
  • Microservices drastically improve the time required to push out a new update, allowing a much more agile development process.
  • Many organizations consist of specialized silo teams (UI, database, API, etc) where costly handoffs and intercommunication are required to coordinate all the pieces of application construction. These handoffs cause overhead, and the need for them should be eliminated.
  • With small teams, each focused on an individual microservice, Netflix enables developers to push code to production, instead of getting mired in a complex deployment process involving several teams.
  • With microservices, the old IT mindset just doesn't work.
  • A centralized IT department cannot possibly cover the wide array of technologies spanning all microservices.
  • Instead a DevOps structure, where each team is responsible for the management of the corresponding microservice, is essential.
  • Enable developers to concoct systems of their choosing with minimal or no interaction from IT, management, VPs, hardware or other groups. "Self Service" is one of the major capabilities offered by the cloud and there's every reason to take advantage of this.
  • Now, IT can be considered as a cloud API available to the developer on-demand 24x7, instead of a complex, process-mired division hidden behind obscure process.
Pablo Lalloni

Microservices and PaaS - Part II | ActiveState - 0 views

  • All aspects of deployment, monitoring, testing, and recovery must be fully automated.
  • Refactor database schemas, and de-normalize everything, to allow complete separation and partitioning of data.
  • There should be no sharing of underlying tables that span multiple microservices, and no sharing of data. Instead, if several services need access to the same data, it should be shared via a service API (such as a published REST or a message service interface).
    • Pablo Lalloni
       
      Aleluya!
  • ...5 more annotations...
  • Instead each microservice should have its own scm repository so it can truly be updated and enhanced independent of other services.
  • Gone are the days of a single monolithic database instance that's shared across all parts of an application.
  • Each microservice must have its own manifest and dependencies, instead of maintaining a global dependency list for all services.
  • Containerization brings countless advantages, particularly a consistent, isolated runtime environment that can easily migrate around the datacenter or around the globe. With Docker and other modern containerization approaches, there is very little overhead in running in a container, and considerable upside.
  • Do not build stateful services. Instead, maintain state in a dedicated persistence service, or elsewhere.
Pablo Lalloni

http://labs.oracle.com/techrep/1994/smli_tr-94-29.pdf - 0 views

  •  
    Asombroso: un paper de 1994 de investigadores de Sun en el cual concluyen que "RPC" está roto de varias maneras y que no se puede arreglar con ninguna implementación. Ummm... ¿de qué año era CORBA? ¿de qué año era EJB?
Pablo Lalloni

Stevey's Google Platforms Rant I was at Amazon for about six and a half years,… - 0 views

  •  
    "The best article I've ever read about architecture and the management of IT."
Pablo Lalloni

The Architecture of Open Source Applications - 0 views

  •  
    Gran colección de análisis de arquitectura de muchos sistemas open-source de diversa escala. ¡Invaluable!
Pablo Lalloni

Pacto - 0 views

  •  
    Pacto judges the contracts between consumers and providers of RESTful services. It can aid in designing realistic test doubles, by ensuring the double complies with the same contract as the real service. It can also aid with service evolution patterns, like Consumer-Driven Contracts or Documentation-Driven Contracts. Pacto ensures consumers meet their contractual obligations: Send the required HTTP request headers Send an appropriate request body (when required) Pacto also ensures providers meet their contractual obligations: Send an appropriate response code Send the required HTTP response headers Send an appropriate response body Pacto can also ensure the provider and consumer collaborate appropriately. It can ensure that for a given scenario: The consumer calls the expected service(s) with a valid request The provider sends a valid response No unexpected services were called
Pablo Lalloni

RGT | Home - 1 views

  •  
    Herramienta para análisis y documentación de toma de decisiones de arquitectura de software. 
Pablo Lalloni

lauris/awesome-scala - 1 views

  •  
    "A community driven list of useful Scala libraries, frameworks and software."
Pablo Lalloni

TinkerPop - 2 views

  •  
    Open source software products in the graph space
1 - 20 of 37 Next ›
Showing 20 items per page