Developers spend up to 20% of their time writing repetitive code that machines could generate more reliably. This presentation explores the problem of duplicated source code that stems from manual implementation of patterns and reveals how to automate the boring side of programming and get a 19x ROI.
The presentation provides insight into:
- the problem of manual implementation of patterns, resulting in boilerplate code
- the cost of boilerplate for companies
- existing technologies for pattern automation
- the key reasons to consider pattern-aware compiler extensions
The white paper was written for CTOs, software architects and senior developers in software-driven organizations—specifically in financial, insurance, healthcare, energy and IT industries that typically write a lot of repetitive code.
Implementing Test Automation in Agile ProjectsMichael Palotas
This document discusses test automation practices at eBay. It begins by providing facts about eBay as a company and platform. It then outlines eBay's approach to test automation, which involves designing automated tests using test aspects, modeling the business domain layer, and implementing tests using Selenium. The document advocates for a lean approach to test automation to avoid technical debt and waste. It emphasizes automating regression tests first before expanding to other test types and executing tests in parallel using a Selenium Grid for faster feedback.
Release software is no less important than activities that precede it.
The Continuous Delivery is a set of practices and methodologies that build an ecosystem for the software development lifecycle.
We will see how to build this ecosystem around the applications developed, for which this release activities becomes a low-risk, inexpensive, fast and predictable.
The Continuous delivery Value @ codemotion 2014David Funaro
System Crash, failure data migration, partial update: issues that no one would ever want to meet during the deploy and ... hoping for the best is not enough.
The deployment activity is important as those that precede it. The Continuous Delivery will give you low risk, cheap, fast, predictable delivery and ... soundly.
Build software like a bag of marbles, not a castle of LEGO®Hannes Lowette
Hannes Lowette discusses how to structure software code like a bag of marbles rather than a LEGO castle. The document describes challenges faced with a tightly coupled codebase and how adopting an onion architecture approach using plugins allowed for more modular and maintainable code. Key points include defining clean dependencies and interfaces, making core business logic decoupled and testable, and enabling new features to be added and removed through plugins without polluting the core codebase.
Enhanced Verification Flow with Nextop's Assertion Synthesis TechnologyDVClub
This document outlines Broadcom's experience enhancing its chip verification flow with Nextop's BugScope assertion synthesis technology. Broadcom was finding bugs late in the verification process using its traditional methodology. BugScope helped address this by automatically generating assertions that find corner case bugs missed previously and improve debug and coverage closure. Using BugScope, Broadcom found bugs in most blocks during property review and noticed improved functional coverage and visibility. While seeing benefits, Broadcom also provides ideas to further improve the tool, such as supporting cross-module properties and a GUI for classification. Overall, Broadcom finds assertion synthesis a natural addition that improves block verification quality and observability in chip testing.
Is Advanced Verification for FPGA based Logic neededchiportal
The document discusses the need for advanced verification in FPGA-based logic design. It argues that FPGAs have similar complexity issues as ASICs for high-quality applications. While FPGAs allow for reprogramming, current FPGA verification relies on manual testing and debugging which has long cycle times and lacks visibility into test quality. The document proposes a new coverage-driven verification methodology using constrained random testing to improve productivity, quality, and certification. It demonstrates this methodology and discusses how it can find more bugs than manual testing while being less expensive.
Behaviour testing for single-page applications and API’sAndrew Kirkpatrick
The document discusses behavior testing for single-page applications and APIs. It covers how testing the web has evolved as applications have become more dynamic and separated into front-end and back-end codebases. This has made end-to-end testing more complex. The document advocates for behavior driven development (BDD) using a tool like Behat, which allows writing tests in a business-readable language called Gherkin that can test both the front-end and back-end applications and their integration. Examples are given of how to set up BDD testing across multiple containers to test the full system behavior.
Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily - leading to multiple integrations per day.
Setting up Continuous Delivery Culture for a Large Scale Mobile AppNaresh Jain
Hike is a mobile-first, messaging platform that is used by 100 million users to exchange 40 billion messages/month. Hike app is available on Android, iOS and Windows phone. On the back-end, we’ve 100+ macro-services in Java, Python, Ruby, Go and Elixir. While setting up a Continuous Delivery pipeline, we ran into a series of technical challenges. However it was more important to address the organisational/behavioural challenges to ensure a sustainable culture shift in the company.
In this talk, I cover how we went about:
* Setup a trunk-based development model
* Decentralised our build & test environments using Docker and Jenkins
* Segregated and containerised our macro-services
* Refactored the mobile apps to be more container friendly
* Setup a mobile device farm using STF
* Improved the quality of code-reviews using PRBuilder & PRRiskAdvisor
* Created different kinds of automated tests to align with our CI Pipeline and get rapid feedback
* Finally how we used C3 to visualise the health of our code-base
The document discusses efficient verification methodology. It recommends defining a conceptual framework or methodology to standardize some aspects while allowing diversity. The methodology should define interfaces and transactions upfront using an interface definition language to generate verification components and reusable assertions. It also recommends modeling systems at the transaction level using executable specifications to frontload the verification schedule.
Встреча "QA: в каких направлениях может найти себя тестировщик?"GoIT
19.12.2014 в креативном пространстве "Часопыс" состоялась очередная встреча от проекта GoIT, посвященная "вечному". Наши любимые преподаватели и менторы доносили следующее:
• Виды QA и специфика работы в каждом из этих направлений;
• Необходимые вспомогательные навыки, которыми должен обладать тестировщик;
• Новинки мира QA.
Наши спикеры:
Николай Ковш - QA Engineer в Ciklum, которому успешно удалось перейти в сферу IT из маркетинга. Расскажет о необходимости тестировщикам уметь программировать.
Алла Пенальба - QA Lead в компании invisibleCRM, работала в компании ПИКСУС, 4 года проживала в Бельгии, где работала Mobile QA Engineer.
Марина Шевченко - Mobile QA Engineer в Ciklum. QA с опытом тестирования веб, десктопных и мобильных приложений. Расскажет о специфике тестирования мобильных приложений.
Александр Майданюк - Head of Quality Assurance Solution в компании Ciklum. Занимал должности QA Lead, Manager, QA Consultant и Trainer. Эксперт и судья QA секции чемпионата UA Web Challenge. Соучредитель Киевского клуба тестировщиков QA Club.
Building trust within the organization, first steps towards DevOpsGuido Serra
This document discusses building trust within an organization through a DevOps approach. It introduces the role of a DevOps person to deliver features, mediate between devs and ops, and address non-functional requirements. It outlines steps taken such as listening to stakeholders, gathering requirements, and prioritizing non-functional needs. Tools are proposed for logging, metrics, and testing to provide transparency and shared understanding across teams. Results seen include improved support, proactive issue fixing, and better product performance through data and testing collaboration.
The document discusses containerizing legacy applications that rely on dynamic file-based configurations and secrets. It begins by asking questions to gauge how many organizations have legacy applications and what challenges they pose. It then outlines steps to containerize a legacy application like MyBB without rewriting code, including running the application in a container, using templated static configuration files injected by an orchestrator, and updating configuration dynamically. The presentation aims to provide a practical approach for migrating difficult-to-maintain legacy applications to containers.
This document provides guidance on how to become a testing expert. It discusses typical interview questions faced by testers and the dilemmas of both testers and management in hiring strong testing candidates. It outlines the career journey of one individual who grew from their first testing role to leadership positions. Key lessons include gaining experience over time and having the ability to find critical bugs quickly. Attributes of a testing expert are developing comprehensive testing strategies and managing the entire release process.
This presentation has been prepared to share knowledge about JetBrains UpSource tool usage on HTML project for back-end developers. Also code review process description has been provided to share good/bad experience of code review procedure.
Why your company loves to welcome change but sucks at accommodating itFarooq Ali
The need for sound engineering practices in Agile. A look at a very common Agile anti-pattern (Flaccid Scrum) found in large organizations, and how to fix it.
The document discusses how Behavior Driven Development (BDD) and the tool SpecFlow can help address common challenges for BizTalk projects. BDD uses a Given/When/Then syntax to define features and scenarios in a way that is understandable to both technical and business stakeholders. SpecFlow allows these scenarios to be defined in .NET and then tested against BizTalk implementations. This approach provides requirements that are close to the code, simplifies documentation, and creates an abstraction layer between tests and implementations that makes intentions clearer. While some BizUnit steps still require implementation, overall BDD offers ways to streamline requirements, documentation, and testing for established BizTalk teams.
Making software development processes to work for youAmbientia
Mikko Paukkila discusses optimizing software development processes to balance bureaucracy and flexibility. He advocates for continuous integration to find errors early and speed up feedback loops. Tools like Git, Jenkins, Gerrit enable CI by automating builds, testing and code reviews. Process optimizations include reducing time from change to product, automating more tests, and ensuring developers have easy environments and fast feedback. The goal is enabling smooth development flows from needs to requirements to changes to high quality products.
Code coverage is a measure of how much of the source code of a program is tested by a test suite. It helps ensure quality by enabling early detection of flaws. Common types of code coverage include statement, function, path, condition, and branch coverage. Tools like Cobertura, Clover, and Emma can help measure and analyze code coverage. Aim for 70-80% test coverage but 100% is not always cost effective or possible. Code coverage should be implemented from the start of development.
Java is a general-purpose, object-oriented programming language that is designed to be platform independent and "write once, run anywhere". It uses a bytecode that is executed by a Java Virtual Machine (JVM) available for most operating systems, allowing code to run on different platforms without recompilation. Java code is compiled into bytecode, then executed by the JVM rather than directly by the native hardware and operating system, making it portable. The Java language has advantages of being simple, secure, portable, object-oriented, robust, multithreaded, architecture-neutral, interpreted and high performance.
Advanced Defensive Coding Techniques (with Introduction to Design by Contract)PostSharp Technologies
Structured exception handling and defensive programming are the two pillars of robust software.
Both pillars fail however when it comes to handling internal faults, those that normally originate in software defects rather than in any external factors.
In this webinar, Zoran Horvat demonstrates advanced defensive coding techniques that can bring the quality of your code to an entirely new level.
Watch the webinar and learn:
When throwing an exception is the right thing to do
Why exceptions and defensive coding cannot be applied to recover from defects
How to handle situations when internal software defect is causing the fault
How to treat fault detection as an orthogonal concern to normal operation
The webinar recording can be found here:
http://www.postsharp.net/blog/post/webinar-recording-defensive-programming
This document provides an overview of the Java programming language. It discusses what Java is, how to write and compile Java code, classes and objects in Java, differences between Java and C++, advantages and disadvantages of Java. Key points covered include Java being a platform-independent, object-oriented language developed by Sun Microsystems, the structure of a Java program using classes and the main method, and how to output text and variables using print statements.
Modern application lifecycle management (ALM) practices can help accelerate business agility by enabling value delivery through agility, quality, and scale. These practices involve planning with business stakeholders and product owners, developing and testing with developers and testers, releasing working software, and monitoring and learning from operations. Implementing the right people, processes, and tools at each stage of plan, develop, release, and operate allows organizations to more quickly plan, develop high quality software, release at scale, and continuously improve based on operational insights.
The document discusses the new features introduced in C# 6.0. It first provides background on the evolution of C# and the .NET Compiler Platform project called Roslyn. It then outlines the major new features in C# 6.0, including auto-property enhancements, primary constructors, using static, string interpolation, expression-bodied members, declaration expressions, exception filters, binary literals with digit separators, indexed members and element initializers, await in catch/finally blocks, and null-conditional operators. It concludes with information about the presenter and a note about contacting him.
Modern business applications rely heavily on rich domain classes, which in turn rely heavily on polymorphic execution, code reuse and similar concepts.
How can we extend rich domain classes to support complex requirements?
In this presentation, Zoran Horvat will show why an object composition approach is favored over class inheritance when it comes to code reuse and polymorphism.
The presentation covers:
How class inheritance can lead to combinatorial explosion of classes
What the limitations of object composition are
What design patterns help consume composed objects
Techniques for creating rich features on composed objects
Watch the webinar recording here: http://www.postsharp.net/blog/post/webinar-recording-object-composition
This presentation provides an overview of basic grammar concepts including parts of speech. It defines grammar as a system of language and means of communication. It then defines and provides examples of different parts of speech including nouns, verbs, adjectives, adverbs, pronouns, prepositions, conjunctions, and interjections. For each part of speech, it explains what it is, provides examples, and discusses related concepts like verb tenses, degrees of adjectives, and types of conjunctions. The presentation emphasizes the importance of proper grammar in business communications for maintaining credibility and a good reputation.
Cloud computing involves delivering IT services over the internet. These services include infrastructure, platforms, and software and are provided on-demand via models such as IaaS, PaaS, and SaaS. Cloud types include public, private, hybrid and community clouds depending on whether the cloud is accessible publicly or within a private network. Key characteristics of cloud include on-demand self-service, broad network access, resource pooling and rapid elasticity.
The document discusses the architecture of the Java Virtual Machine (JVM). It describes how Java source code is compiled to bytecode, which is then converted by the JVM into machine code that can be executed by the operating system. The JVM divides memory into class, stack, and heap segments. Bytecode is loaded into the class segment and converted to machine code by the class loader and just-in-time compiler. Objects are stored in the heap segment and references to those objects are stored on the stack. The JVM manages memory and execution with modules like the memory manager, execution engine, class loader, and exception handler that communicate with the underlying operating system.
This document discusses garbage collection techniques for automatically reclaiming memory from unused objects. It describes several garbage collection algorithms including reference counting, mark-and-sweep, and copying collection. It also covers optimizations like generational collection which focuses collection on younger object generations. The goal of garbage collection is to promote memory safety and management while allowing for automatic reclamation of memory from objects that are no longer reachable.
Exception handling in Java provides a mechanism to handle runtime errors so the normal flow of an application can be maintained. Errors are irrecoverable issues like OutOfMemoryError while exceptions are recoverable, such as ArithmeticException. The try block identifies exceptions, throw passes exceptions to catch which handles them, and finally always executes. Throws allows methods to declare exceptions instead of handling them.
The document discusses the history and evolution of JavaScript, including its origins from Java and LiveScript, standardization as ECMAScript, and key features such as dynamic typing, objects, functions, and prototypal inheritance. It also covers JavaScript data types like numbers, strings, Booleans, objects, and functions, and how the language handles values, scope, operators, and other elements.
The document compares and contrasts Java and .NET frameworks. It discusses how both use intermediate languages - Java uses bytecode that runs on the Java Virtual Machine (JVM) and .NET uses Microsoft Intermediate Language (MSIL) that runs on the Common Language Runtime (CLR). Both frameworks allow applications to run across platforms, however the JVM was designed for platform independence while .NET was initially only supported on Windows. The document also notes that the choice between Java and .NET often comes down to non-technical factors like developer skills and customer/vendor preferences.
The document discusses different types of errors in Java including compile-time errors, run-time errors, and exceptions. It defines exceptions as events that disrupt normal program flow and describes Java's exception handling mechanism which includes throwing, catching, and handling exceptions using try, catch, throw, throws and finally keywords. The document also covers checked and unchecked exceptions, nested try blocks, and rethrowing and declaring exceptions using throws.
The document discusses static analysis and error checking in compiler construction. It introduces key concepts like parsing source code, performing static semantic checks, and generating machine code. Specific techniques covered include name analysis, type systems, formal semantics, and testing static analysis. Examples are provided using Tiger, a simple imperative language, to illustrate type rules and name binding. The document also discusses theoretical foundations in formal language theory and decidability/complexity.
This document discusses register allocation in compiler construction. It begins with an example of constructing an interference graph from a code snippet during liveness analysis. It then covers the main steps of register allocation: constructing interference graphs from liveness analysis, graph coloring to assign registers while minimizing spills, and handling move instructions through coalescing. It provides examples demonstrating graph coloring on interference graphs with different numbers of available registers.
The document outlines new features in Visual Studio 2017 including lightweight solution loading, modifying extensions in bulk, a roaming extension manager, a new exception helper, attaching to processes, running to click, finding all references, a structure visualizer, IntelliSense filtering, match highlighting, and improved code navigation. It also provides a reference to the Visual Studio 2017 release notes and allocates time for questions and answers.
This document discusses code generation in .NET. It begins by outlining some common problems developers face when dealing with large amounts of repetitive code. It then discusses various approaches to solving this problem, including hand coding everything, fully generic design, and using a combination of tools including code generation. The rest of the document discusses specific code generation tools for .NET like StringBuilder, CodeSnippets, XSLT, Reflection.Emit, EnvDTE, CodeDom, and T4. It also discusses pros and cons of each approach and provides examples of using code generation in different real world scenarios.
The View - Lotusscript coding best practicesBill Buchan
This document discusses best practices for LotusScript coding. It covers topics like code structure, using short logical functions, defensive programming, variable naming conventions, and ensuring variables only exist as long as needed. The goal is to write code that is maintainable, reusable, and robust. Testing practices like test-driven development and separating development, testing, and production environments are also recommended to improve quality.
Slides for Houston iPhone Developers' Meetup (April 2012)lqi
The document discusses the importance of code quality and provides tips for improving code quality. It defines code quality as how well software is designed and implemented. It recommends code reviews, static analysis tools like Clang, AppCode, and OCLint to identify code smells and defects. It also discusses refactoring code to improve simplicity, clarity and reduce technical debt. Maintaining high code quality makes software easier to change and evolve over time.
The document discusses coding standards, code reviews, and related tools. It emphasizes that coding standards provide structure and consistency that avoids arbitrary variations. Standards help produce unified, understandable code and reduce bugs. The document outlines some specific standards for areas like commenting, naming, collections, and exceptions. It addresses adopting standards through incremental changes and code reviews. Code reviews are presented as an important way to catch bugs early, enhance learning, and promote collective code ownership. Various tools for code analysis, style checking, and code metrics are also mentioned.
In this talk, I will discuss our experiences at Mollie with setting up the Jenkins Continuous Integration server for all our PHP projects. The talk will be aimed at developers with little or no experience with CI.
Capability Building for Cyber Defense: Software Walk through and Screening Maven Logix
Dr. Fahim Arif who is the Director R&D at MCS, principal investigator and GHQ authorized consultant for Nexsource Pak (Pvt) Ltd) discussed the capability of building cyber defense in the Data Protection and Cyber Security event that was hosted recently by Maven Logix. In his session he gave the audience valuable information about the life cycle of a cyber-threat discussing what and how to take measures by performing formal code reviews, code inspections. He discussed essential elements of code review, paired programming and alternatives to treat and tackle cyber-threat
XP teams try to keep systems fully integrated at all times, and shorten the feedback cycle to minutes and hours instead of weeks or months. The sooner you know, the sooner you can adapt.
Watch our record for the webinar "Continuous Integration" to explore how Azure DevOps helps us in achieving continuous feedback using continuous integration.
Raquel Pau discusses strategies for managing technical debt. She defines technical debt as code that is easy to implement in the short run but not the best overall solution. While some technical debt is inevitable when pursuing a minimum viable product strategy, it is important to measure all debt, control increases with quality gates and code reviews, and prioritize reducing existing debt through a "merciless" cleanup approach. Different types of technical debt include architectural, testing, code standards, infrastructure, and knowledge debt. Metrics, consequences, and solutions are proposed for managing each type of debt.
This presentation is a part of the COP2271C college level course taught at the Florida Polytechnic University located in Lakeland Florida. The purpose of this course is to introduce Freshmen students to both the process of software development and to the Python language.
The course is one semester in length and meets for 2 hours twice a week. The Instructor is Dr. Jim Anderson.
A video of Dr. Anderson using these slides is available on YouTube at:
https://youtu.be/KcFCcCsn6mM
Software Architecture and Architectors: useless VS valuableComsysto Reply GmbH
The document discusses several cases where architecture decisions hurt software teams. It provides lessons learned from each case:
- Overly sharing code across domains can cause dependencies and fragility. Architectural boundaries should separate domains.
- Attempting to satisfy all use cases with a single highly configurable solution often satisfies no one. Specific solutions may be preferable.
- Microservices are not a universal solution and will not improve a flawed design alone. Modules should only be split across microservices at domain boundaries.
- Systems need to be designed to evolve dynamically over time as requirements change. Centralized control hinders this.
Continuous integration (CI) with TeamCity automates the software building and testing process. It allows developers to check in code frequently and have builds run automatically to detect issues early. TeamCity monitors source code repositories for changes, builds the code, and runs tests on each change. This helps ensure all code components work together, coding standards are followed, and tests are passing. CI with TeamCity provides benefits like reduced risks from early defect detection, increased visibility into the project, and confidence in the software.
Quality metrics and angular js applicationsnadeembtech
This document discusses various ways to measure and ensure code quality in JavaScript programs. It covers topics like linting, testing, complexity analysis, and static code analysis. Linters like JSHint and ESLint can check for style and syntax issues. Testing tools like Jasmine, Karma, and Protractor allow writing unit and integration tests. Complexity can be measured using metrics related to lines of code, arguments, nesting, and more. Tools like Plato and complexity-report provide metrics and visualizations. Adopting these practices helps reduce bugs and technical debt.
The document provides an introduction to programming concepts like programs, programming, and basic procedures. It discusses what a program is, the input-process-output model of programming, and basic programming procedures like sequence, selection, and repetition. It also covers the Visual Basic .NET integrated development environment and changes from Visual Basic 6, including how forms are now classes, new data types like Decimal replacing Currency, and changes to syntax like requiring parentheses for calling subs and functions.
Client Technical Analysis of Legacy Software and Future ReplacementVictorSzoltysek
The client had a legacy PHP codebase for Google Adword integration with a MySQL database that had become monolithic and difficult to modify. They wanted to replace it with a microservices architecture using Groovy, Cassandra, and separate codebases. However, this led to increased complexity, technical debt, and slower performance than the original system. It would have been better to take an incremental approach, keeping the system simple, and deferring optimizations until proven necessary by real metrics and business needs.
Abstract
The idea of this talk is to help development teams to make correct architectural decisions.
Andrei will highlight the basic architectural principles and show ways to achieve architecture that is good enough to cover the project requirements and evolve in the future.
He will also present several cases from real projects, where wrong, missing, or over-sophisticated architecture decisions really hurt the development teams:
- Painful sharing: do shared modules increase reusability or will be the source of problems?
- Microservices are the solution to every problem!
- Non-extensible extensibility: too sophisticated configuration hurts
- Over fine-grained: incorrect splitting to Microservices can make life even harder as with monolith
- Convey horizontal split: how organizational driven split can jeopardise the architecture
- Model-driven: central responsibility blocks and limits the team
- Cargo cult: blindly following patterns and rule can produce an unmaintainable system
- Freestyle architecture: what happens if teams completely ignore architecture
- Improve with less intelligence: smart endpoint and dumb pipes
Abstract
The idea of this talk is to help development teams to make correct architectural decisions.
Andrei will highlight the basic architectural principles and show ways to achieve architecture that is good enough to cover the project requirements and evolve in the future.
He will also present several cases from real projects, where wrong, missing, or over-sophisticated architecture decisions really hurt the development teams:
- Painful sharing: do shared modules increase reusability or will be the source of problems?
- Microservices are the solution to every problem!
- Non-extensible extensibility: too sophisticated configuration hurts
- Over fine-grained: incorrect splitting to Microservices can make life even harder as with monolith
- Convey horizontal split: how organizational driven split can jeopardise the architecture
- Model-driven: central responsibility blocks and limits the team
- Cargo cult: blindly following patterns and rule can produce an unmaintainable system
- Freestyle architecture: what happens if teams completely ignore architecture
- Improve with less intelligence: smart endpoint and dumb pipes
This document summarizes a talk on unit testing in JavaScript. It introduces the speaker and their company Third Wave Technology. It then defines unit testing as writing code to test individual units in isolation. The benefits of unit testing are discussed such as speeding up development, providing documentation, and helping write better code. Popular JavaScript unit testing frameworks like QUnit and Jasmine are presented. The document concludes by suggesting factors to consider when choosing a unit testing framework.
Similar to 10 Reasons You MUST Consider Pattern-Aware Programming (20)
Starting with the premise that "Performance is a Feature", Matt Warren will show you how to measure, what to measure and how to get the best performance from your .NET code.
We will look at real-world examples from the Roslyn code-base and StackOverflow (the product), including how the .NET Garbage Collector needs to be tamed!
The presentation covers:
Why we should care about performance
Pitfalls to avoid when measuring performance
How the .NET Garbage Collector can hurt performance
Real-world performance lessons from open-source code
The webinar recording can be found here: http://www.postsharp.net/blog/post/webinar-recording-performance-is-a-feature
How do you avoid the dreaded "this is not what we asked for" and ensure customer satisfaction when building a new system?
In this webinar, Dino Esposito demonstrates a top-down methodology, sometimes mistaken for plain common sense and often boldly ignored, called UX-Driven Design (UXDD).
UXDD means coming to a visual agreement with customers by using wireframing tools to iterate on sketches of the new system before building it. Then, rather than building the system from the data model, you proceed in a top-down fashion instead. The resulting system may be slow or even inefficient but it will never be the “wrong” system! In addition, UXDD leads to clarity on a few of today’s most popular patterns that are sometimes difficult to understand like CQRS and Event Sourcing.
The presentation covers:
An introduction to Wireframing tools
Proven ways to save on post-first deployment costs
Insights into better customer relationships
Better focus on development without 'analysis paralysis'
You can watch the webinar recording here:
http://www.postsharp.net/blog/post/webinar-recording-ux-driven-design
Localization is crucial for reaching out to a global audience, however, it’s often an afterthought for most developers and non-trivial to implement. Traditionally, game developers have outsourced this task due to its time consuming nature.
But it doesn’t have to be this way.
Yan Cui will show you a simple technique his team used at GameSys which allowed them to localize an entire story-driven, episodic MMORPG (with over 5000 items and 1500 quests) in under an hour of work and 50 lines of code, with the help of PostSharp.
When addressing website performance issues, developers typically jump to conclusions, focusing on the perceived causes rather than uncovering the real causes through research.
Mitchel Sellers will show you how to approach website performance issues with a level of consistency that ensures they're properly identified and resolved so you'll avoid jumping to conclusions in the future.
You can watch the webinar recording here:
https://www.postsharp.net/documentation/video?id=190066128
Everybody knows the lock keyword, but how does it implemented? What are its performance characteristics. Gael Fraiteur scratches the surface of multithreaded programming in .NET and goes deep through the Windows Kernel down to CPU microarchitecture.
Gael Fraiteur argues that multithreaded programming needs to be addressed at the right level of abstraction, with design patterns like Actor, Immutable, Freezable, Thread Affine, Reader-Writer-Synchronized. Design patterns form a language and serve as a model against which code can be expressed. Compilers must support design patterns to allow code to be deterministically validated against the model, and of course to generate the low-level instructions that would be otherwise written manually.
This document discusses design pattern automation and the use of pattern-aware compilers. It provides a history of programming languages and patterns, defines design pattern automation as using tools to optimize productivity in implementing software based on patterns. It discusses how pattern-oriented software development involves implementing patterns at multiple levels of abstraction. It also addresses myths around why patterns cannot be automated and argues that emerging design and agile methodologies allow patterns to naturally emerge from iterative design processes. An example of applying automation to the Reader-Writer pattern through code generation and verification is also provided.
This document introduces aspect-oriented programming (AOP) and how it can be used to separate cross-cutting concerns from core business logic. It discusses how AOP frameworks like PostSharp allow aspects to modularize features like logging, transactions, and security. The document provides an example of how a rental booking method grows over time to include these concerns. It compares different AOP frameworks and concludes that PostSharp allows building aspects with strong robustness while minimizing code invasiveness.
introduction of Ansys software and basic and advance knowledge of modelling s...sachin chaurasia
Ansys Mechanical enables you to solve complex structural engineering problems and make better, faster design decisions. With the finite element analysis (FEA) solvers available in the suite, you can customize and automate solutions for your structural mechanics problems and parameterize them to analyze multiple design scenarios. Ansys Mechanical is a dynamic tool that has a complete range of analysis tools.
WhatsApp Tracker - Tracking WhatsApp to Boost Online Safety.pdfonemonitarsoftware
WhatsApp Tracker Software is an effective tool for remotely tracking the target’s WhatsApp activities. It allows users to monitor their loved one’s online behavior to ensure appropriate interactions for responsive device use.
Download this PPTX file and share this information to others.
Are you wondering how to migrate to the Cloud? At the ITB session, we addressed the challenge of managing multiple ColdFusion licenses and AWS EC2 instances. Discover how you can consolidate with just one EC2 instance capable of running over 50 apps using CommandBox ColdFusion. This solution supports both ColdFusion flavors and includes cb-websites, a GoLang binary for managing CommandBox websites.
Sami provided a beginner-friendly introduction to Amazon Web Services (AWS), covering essential terms, products, and services for cloud deployment. Participants explored AWS' latest Gen AI offerings, making it accessible for those starting their cloud journey or integrating AI into coding practices.
A captivating AI chatbot PowerPoint presentation is made with a striking backdrop in order to attract a wider audience. Select this template featuring several AI chatbot visuals to boost audience engagement and spontaneity. With the aid of this multi-colored template, you may make a compelling presentation and get extra bonuses. To easily elucidate your ideas, choose a typeface with vibrant colors. You can include your data regarding utilizing the chatbot methodology to the remaining half of the template.
Seamless PostgreSQL to Snowflake Data Transfer in 8 Simple StepsEstuary Flow
Unlock the full potential of your data by effortlessly migrating from PostgreSQL to Snowflake, the leading cloud data warehouse. This comprehensive guide presents an easy-to-follow 8-step process using Estuary Flow, an open-source data operations platform designed to simplify data pipelines.
Discover how to seamlessly transfer your PostgreSQL data to Snowflake, leveraging Estuary Flow's intuitive interface and powerful real-time replication capabilities. Harness the power of both platforms to create a robust data ecosystem that drives business intelligence, analytics, and data-driven decision-making.
Key Takeaways:
1. Effortless Migration: Learn how to migrate your PostgreSQL data to Snowflake in 8 simple steps, even with limited technical expertise.
2. Real-Time Insights: Achieve near-instantaneous data syncing for up-to-the-minute analytics and reporting.
3. Cost-Effective Solution: Lower your total cost of ownership (TCO) with Estuary Flow's efficient and scalable architecture.
4. Seamless Integration: Combine the strengths of PostgreSQL's transactional power with Snowflake's cloud-native scalability and data warehousing features.
Don't miss out on this opportunity to unlock the full potential of your data. Read & Download this comprehensive guide now and embark on a seamless data journey from PostgreSQL to Snowflake with Estuary Flow!
Try it Free: https://dashboard.estuary.dev/register
Software development... for all? (keynote at ICSOFT'2024)miso_uam
Our world runs on software. It governs all major aspects of our life. It is an enabler for research and innovation, and is critical for business competitivity. Traditional software engineering techniques have achieved high effectiveness, but still may fall short on delivering software at the accelerated pace and with the increasing quality that future scenarios will require.
To attack this issue, some software paradigms raise the automation of software development via higher levels of abstraction through domain-specific languages (e.g., in model-driven engineering) and empowering non-professional developers with the possibility to build their own software (e.g., in low-code development approaches). In a software-demanding world, this is an attractive possibility, and perhaps -- paraphrasing Andy Warhol -- "in the future, everyone will be a developer for 15 minutes". However, to make this possible, methods are required to tweak languages to their context of use (crucial given the diversity of backgrounds and purposes), and the assistance to developers throughout the development process (especially critical for non-professionals).
In this keynote talk at ICSOFT'2024 I presented enabling techniques for this vision, supporting the creation of families of domain-specific languages, their adaptation to the usage context; and the augmentation of low-code environments with assistants and recommender systems to guide developers (professional or not) in the development process.
An MVP (Minimum Viable Product) mobile application is a streamlined version of a mobile app that includes only the core features necessary to address the primary needs of its users. The purpose of an MVP is to validate the app concept with minimal resources, gather user feedback, and identify any areas for improvement before investing in a full-scale development. This approach allows businesses to quickly launch their app, test its market viability, and make data-driven decisions for future enhancements, ensuring a higher likelihood of success and user satisfaction.
Lots of bloggers are using Google AdSense now. It’s getting really popular. With AdSense, bloggers can make money by showing ads on their websites. Read this important article written by the experienced designers of the best website designing company in Delhi –
Top 10 Tips To Get Google AdSense For Your Website
10 Reasons You MUST Consider Pattern-Aware Programming
1. #1 pattern-aware compiler extension to C#/VB
10 Reasons You MUST Consider
Pattern-Aware Programming
By Gael Fraiteur (@gfraiteur),
Founder & CEO of PostSharp Technologies
2. Housekeeping Rules
• Q&A session at the end.
• Please write questions to GoToMeeting chat window.
• The webinar recording will be made available on Friday, July 22th.
4. Thinking with Patterns
• Developers think
at a high level of abstraction,
using design patterns. Window
pattern,
repeated 200x
Door pattern,
repeated 20x
5. Conventional Compilers Are Limited
• Conventional compilers don’t have a
concept of patterns.
• Therefore developers write repeating code:
boilerplate code.
7. Consequences of Boilerplate
• High development effort
• Poor quality of produced software
• Code is more complex than necessary
• Difficulty to add/modify functionality after release 1.0
• Slow ramp-up of new team members
Can you see how boilerplate code slows your development team?
8. The Big Question
• How can we produce high-quality software with less development effort...
without having to replace your existing compiler?
10. Inadequate Technologies
• Dependency Injection
• Just adds behaviors to component boundaries
• Affects your architecture
• Only supports basic patterns
• Great tool, but not for that job.
• Code Generators / Refactoring Tools
• Just makes it easy to generate boilerplate
• You still have to maintain it!
13. 1) Stop Writing Boilerplate and Deliver Faster
• Fewer lines of code means fewer hours of work
• Outsource repetitive work to compiler
and save time and costs immediately
4 REASONS FOR PATTERN-AWARE COMPILERS
14. 2) Build More Reliable Software
• Fewer lines of code means fewer defects
• Reliability becomes much more affordable
• Reliability generally means boilerplate:
logging, exception handling, caching,
security,…
• The “right” tool.
4 REASONS FOR PATTERN-AWARE COMPILERS
15. 3) Easier to Modify Functionality
• Cleaner and shorter code is easier to understand
• Focus on business logic and save time trying
to understand the code
• Better architecture is future-proof
• Define features such as logging, exception
handling or transactions in one place and
make their modification easy and fast
4 REASONS FOR PATTERN-AWARE COMPILERS
16. 4) New Team Members Contribute Quicker
• Simpler code means faster ramp-up
• New team members can focus on business logic
without worrying about complex architectural structures.
• Implement a tighter feedback loop
• Validate hand-written code against
your defined rules at build time
and detect bugs as quickly
4 REASONS FOR PATTERN-AWARE COMPILERS
17. Top 10 Features to Look For
1. Ready-made pattern implementations
2. Threading models
3. Ability to automate complex patterns
4. Ease to add patterns to source code
5. Compatibility with existing codebase
6. Build-Time Validation of Patterns
7. Architecture Validation
8. Integration with Visual Studio
9. Run-Time Performance
10. Commercial Support
18. 1) Ready-Made Pattern Implementations
10 FEATURES TO LOOK FOR
• Don’t reinvent the wheel.
• Would you code your own Graph or DataGrid
controls?
• Look for off-the-shelf pattern implementations.
Demo: INotifyPropertyChanged, undo/redo
19. 2) Threading Models
10 FEATURES TO LOOK FOR
• Simpler: Use the right level of abstraction. Don’t
overwhelm your brain with thousands of tiny details.
• Your choice: Immutable, Freezable, Synchronized,
Reader-Writer Synchronized, Actor, Thread Affine and
Thread Unsafe.
• No more random bugs: Model validation catches
most defects during build or during single-threaded
test coverage.
• Build thread-safe applications!
21. 3) Automate Complex Patterns
• Rich set of primitive transformations
• Decoration: methods
• Interception: methods, properties, fields, events
• Introduction: methods, properties, fields, interfaces, custom attributes
• To any declaration… or just public virtual ones?
• Aspects composed of several transformations
• Several aspects on the same declaration
• Simple API… or complex AST/MSIL transformations?
• Validation of hand-written code against pattern guidelines.
10 FEATURES TO LOOK FOR
22. Example: Weak Event Pattern
• Challenge: Lifetime of event subscriptions controlled by the event client, not the event source.
• Solution: 2 aspects, 1 validation
10 FEATURES TO LOOK FOR
[WeakEventClient]
class MyEventClient
class MyEventSource
{
}
[WeakEvent]
event EventHandler MyEvent;
1.
3.
2.
1. Client adds
handler to
event.
2. Event stores
only weak
reference thanks
to [WeakEvent]
aspect
3. Event adds
handler to source
through
IWeakEventClient
4. [WeakEventClient]
aspect implements
IWeakEventClient interface
and stores strong reference
to event handler.
23. 4) Easy to Add Patterns to Code
• Custom attributes: one by one, hand-picked.
• Multicast attributes: bulk
e.g. add logging to all public methods
• Inheritance
• XML: centrally managed.
• Programmatic at Build-Time: more flexible.
• Programmatic at Run-Time: cool but not a compiler technology
10 FEATURES TO LOOK FOR
24. 5) Compatibility with Existing Codebases
10 FEATURES TO LOOK FOR
• Design Neutrality
• No impact on architecture
• Don’t abuse from dependency injection
• Plain C# and VB
• Get the benefits of F#, Scala, Nemerle, Python,
Ruby or JavaScript in C# and VB
• Cross-platform
• Supports .NET Framework, Windows Phone,
WinRT, Xamarin and Portable Class Libraries
25. 6) Build-Time Pattern Validation
• Emit build-time errors and warnings
• Declarative and programmatic validations
10 FEATURES TO LOOK FOR
10% of developers design patterns and
implement them with aspects.
90% of developers use aspects.
26. 7) Architecture Validation
• Challenge: get large teams respect conventions.
• “Everybody on the team shall solve this problem this specific way”.
• It’s a pattern but it still needs manual work.
• Traditional Solution: Code Review
• Slow feedback loop
• Generates relationship friction
• Better solution: Automatic Validation
• Express conventions as executable code
• Break the build in case of non-compliance.
10 FEATURES TO LOOK FOR
27. 8) Visual Studio Integration
Key questions developers have when coding:
1. What is this piece of code doing?
Which aspects are applied here?
2. Where is this aspect being used?
3. Debugging the business logic with / without the aspects.
10 FEATURES TO LOOK FOR
28. 9) Run-Time Performance
10 FEATURES TO LOOK FOR
• Build-time technology
• Code modification at build time
• Don’t waste time on analysis at run-time
• No reflection at run-time
29. 10) Commercial Support
• Who backs the product?
• Master thesis work vs vested professional software engineers
• Support
• Can you get someone on the phone?
• Documentation
• Quality policies
10 FEATURES TO LOOK FOR
30. What’s Holding You Back?
• Will I be able to understand my code?
• Yes. With proper Visual Studio tooling, you’ll easily understand where and
how patterns are used in your code
• Can I still debug my code?
• Yes. The debugging experience is unaffected.
• Compilation will be slower
• Possibly. Smarter compilers introduce additional steps into the
compilation, there is a performance cost.
31. Return on Investment
• Each line of code costs $14. A commercial tool
typically pays off after a developer saves first 50
lines of code.
• Pattern-aware compilers can reduce source
code by up to 20%. That means $5,000-$20,000
per developer per year!
• 15 to 55 times ROI.
• You never lose – you always win.
32. Picture this
• No more boring and repetitive coding.
• No more spending hours trying to understand the
business logic of the code.
• No more random errors in multithreaded
applications.
• Smoother code reviews.
• Cut development and maintenance costs.
• Go to market faster.
• Produce high-quality, easy-to-maintain software
that has fewer bugs – with less development
effort.
Life is Good!
33. This webinar is brought to you by…
#1 best-selling pattern-aware compiler extension to C#/VB
34. Trusted by the World’s Largest Corporations
• Trusted by over 50,000 satisfied
developers worldwide
• Over 1,000 of the world’s largest
corporations
• More than 10% of all Fortune 500
companies rely on PostSharp
All trust…
35. For More Information
• Go to www.postsharp.net/download
and start the free trial.
• Download the white paper from
https://www.postsharp.net/product/white-papers.
• Read case studies and testimonials
on www.postsharp.net/customers.
• Contact us at hello@postsharp.net
with any questions.
Conventional programming languages like C# and Visual Basic miss a concept of pattern, therefore patterns like threading, INotifyPropertyChanged or logging are hand-coded and result in a large amount of boilerplate code. This boilerplate code adds up to:
High development effort: some features require a large amount of repetitive code when implemented manually
The quality of the produced software is poor as it contains high number of defects. Code that stems from copy-paste programming is more likely than other to be buggy because subtle differences are often overlooked. The applications we develop often lack robustness as enterprise-grade features such as exception handling or caching are often deliberately omitted because of the high amount of source code they imply.
It’s difficult to add/modify functionality after first release because the business code is often littered with low-level non-functional requirements and so is more difficult to understand and maintain. Features like logging, exception handling or INotifyPropertyChanged are often scattered among thousands of files, making it very difficult to change their implementation.
Codebases with a lot of boilerplate slow down the ramp-up of new team members as they often must first learn about caching, threading and other highly technical issues before being able to contribute to the business value. There are also long feedback loops even in small development teams as common patterns like diagnostics, logging, threading, INotifyPropertyChanged and undo/redo can be handled differently by each developer. Architects need to make sure new team members understand and follow the internal design standards and have to spend more time on manual code reviews--delaying progress while new team members wait to get feedback from code review.
Wouldn't it be nice to produce high-quality, software that is easy to maintain with less development effort and faster ramp-up of new team members... without having to replace your existing compiler? You may want to consider…
Pattern-Aware Compiler Extensions.
They extend conventional object-oriented programming with a concept of pattern and so patterns do not need to be manually implemented as boilerplate code. Features such as INotifyPropertyChanged, logging, transactions are implemented in a cleaner, more concise way, making development and maintenance much easier.
Stop writing boilerplate and deliver faster
As you stop implementing patterns manually and outsource the repetitive work to the compiler, you will need less lines of code to deliver a functionality. Fewer lines of code means fewer hours of work so you’ll be able to deliver features faster and save development time and costs immediately
2. Build more reliable software
• With a pattern-aware compiler eliminating the boilerplate, your code becomes easier to read, understand and modify, and contains fewer defects.
• Reliability becomes much more affordable. Because reliability features such as caching or exception handling no longer require so much manual coding, they are much easier and cheaper to implement. You can spend your extra time building a more robust app.
3. Pattern-aware compiler extensions make it easier to add or modify functionality.
• Cleaner and shorter code is easier to understand. After the initial release, too much development time is spent on reading and analyzing source code, especially if the initial developer left. With minimized boilerplate code, developers can easily focus on business logic and spend much less time trying to understand the code.
• Better architecture is future-proof. Using a pattern-aware compiler, features like logging, exception handling or transactions are no longer scattered among thousands of files but they are defined in one place, making it much easier and fast to modify when necessary.
4. New team members contribute quicker
• Pattern-aware compilers help new team members contribute quicker and achieve a better division of labor. Because your codebase is cleaner, new or junior team members can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
• Implement a tighter feedback loop. A pattern-aware compiler can validate that hand-written code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.
There are 4 reasons why to consider pattern-aware compiler extensions:
They help you stop writing boilerplate code and deliver faster because patterns do not need to be manually implemented as boilerplate code.
You can build more reliable software
They make it easier to add/modify functionality after first release
New team members can contribute quicker thanks to cleaner codebase
4. New team members contribute quicker
• Pattern-aware compilers help new team members contribute quicker and achieve a better division of labor. Because your codebase is cleaner, new or junior team members can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
• Implement a tighter feedback loop. A pattern-aware compiler can validate that hand-written code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.
4. New team members contribute quicker
• Pattern-aware compilers help new team members contribute quicker and achieve a better division of labor. Because your codebase is cleaner, new or junior team members can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
• Implement a tighter feedback loop. A pattern-aware compiler can validate that hand-written code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.
4. New team members contribute quicker
• Pattern-aware compilers help new team members contribute quicker and achieve a better division of labor. Because your codebase is cleaner, new or junior team members can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
• Implement a tighter feedback loop. A pattern-aware compiler can validate that hand-written code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.
4. New team members contribute quicker
• Pattern-aware compilers help new team members contribute quicker and achieve a better division of labor. Because your codebase is cleaner, new or junior team members can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
• Implement a tighter feedback loop. A pattern-aware compiler can validate that hand-written code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.
4. New team members contribute quicker
• Pattern-aware compilers help new team members contribute quicker and achieve a better division of labor. Because your codebase is cleaner, new or junior team members can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
• Implement a tighter feedback loop. A pattern-aware compiler can validate that hand-written code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.
4. New team members contribute quicker
• Pattern-aware compilers help new team members contribute quicker and achieve a better division of labor. Because your codebase is cleaner, new or junior team members can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
• Implement a tighter feedback loop. A pattern-aware compiler can validate that hand-written code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.
4. New team members contribute quicker
• Pattern-aware compilers help new team members contribute quicker and achieve a better division of labor. Because your codebase is cleaner, new or junior team members can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
• Implement a tighter feedback loop. A pattern-aware compiler can validate that hand-written code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.
4. New team members contribute quicker
• Pattern-aware compilers help new team members contribute quicker and achieve a better division of labor. Because your codebase is cleaner, new or junior team members can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
• Implement a tighter feedback loop. A pattern-aware compiler can validate that hand-written code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.
4. New team members contribute quicker
• Pattern-aware compilers help new team members contribute quicker and achieve a better division of labor. Because your codebase is cleaner, new or junior team members can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
• Implement a tighter feedback loop. A pattern-aware compiler can validate that hand-written code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.
4. New team members contribute quicker
• Pattern-aware compilers help new team members contribute quicker and achieve a better division of labor. Because your codebase is cleaner, new or junior team members can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
• Implement a tighter feedback loop. A pattern-aware compiler can validate that hand-written code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.
Following are the most common questions about PostSharp:
Will I be able to understand my code?
Yes. Thanks to PostSharp’s Visual Studio tooling, you’ll easily understand where and how patterns are used in your code
Can I keep using my existing compiler?
Yes. PostSharp is 100% compatible with your existing Microsoft compiler
Compilation will be slower
Possibly. PostSharp introduces additional steps into the compilation, there is a performance cost. However, PostSharp is highly optimized several times faster than FxCop, etc.
The detailed document on how ROI is calculated can be provided on request. A few background information on the data:
For a cost of only 350$ -- cost of PostSharp license per developer if purchased 5 licenses with 3 years of maintenance (=$5,212 – public price))
Cost for 1 developer is $95k – source: https://visualstudiomagazine.com/articles/salary-surveys/salary-survey.aspx
1 developer typically produces 600 lines of code per month – source: McConnell, Steve (2006-02-22). Software Estimation: Demystifying the Black Art. Pearson Education.
PostSharp pays off after he/she saves first 50 lines of code -- Average price for the first year for a 5-dev team: 665$
Think about the last time your developers found it painful to implement a feature manually or modify functionality in existing software, and then never think of it again. Imagine you could produce high-quality software that is easy to maintain and has fewer bugs – all with less development effort. No more copying and pasting blocks of code to add a functionality. No more spending hours trying to understand the business logic of the code. No more hiring an expensive specialists to build thread-safe applications. Deliver the same functionality faster with less development costs. Stop imagining. Get to know PostSharp, the #1 best-selling pattern-aware extension to C# and VB,and improve your developers’ efficiency and lives.
Now that you have seen some of the benefits of using a pattern-aware compiler, let's talk about the main reasons you may wish to consider PostSharp, the #1 best-selling pattern-aware compiler extension to C# and Visual Basic.
Trusted by over 50,000 developers worldwide and over 1,000 leading corporations. More than10% of all Fortune 500 companies including Microsoft, Intel, Bank of America, Phillips, NetApp, BP, Comcast, Volkswagen, Hitachi, Deutsche Bank, Bosch, Siemens, and Oracle rely on PostSharp to reduce their development and maintenance costs.
Steps to Actuate
Sign up for free trial
See more features and code examples on www.postsharp.net
Read case studies and testimonials of satisfied customers
Attend a free live webinar
Get the price or request a quote
Contact us with any questions