• Like
ABSE and AtomWeaver : A Quantum Leap in Software Development
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

ABSE and AtomWeaver : A Quantum Leap in Software Development

  • 10,719 views
Published

ABSE is a Model-Driven Software Development methodology that lets you generate the code you want. Capture your own developments skills into easy reusable assets. AtomWeaver is an IDE that implements …

ABSE is a Model-Driven Software Development methodology that lets you generate the code you want. Capture your own developments skills into easy reusable assets. AtomWeaver is an IDE that implements ABSE, allowing you to save time and be more productive while developing your software project.

Published in Technology , Business
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
10,719
On SlideShare
0
From Embeds
0
Number of Embeds
1

Actions

Shares
Downloads
31
Comments
0
Likes
2

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. ABSE and AtomWeaverA Quantum Leap in Software Development
  • 2. PART IAbout Software DevelopmentA critical look into software development
  • 3. Software, Everywhere From wrist watches to the Space Shuttle, software is everywhere Every day, millions of lines of code are written by thousands of software developers around the world Our society becomes more dependent on software every passing day
  • 4. Increasing Software Complexity Every system, every application, in every version, in any domain, gets more complex at each iteraction Evolution in lines of code on typical systems 70s 90s 2010 Cell Phone - 100.000 10.000.000 High-End Car 100.000 1.000.000 100.000.000 (GM/IBM Estimates) Word Processor - 78.000 2.000.000+ (Word 4.0 DOS) Operating System 10.000 4.500.000 50.000.000+ (Unix v1) (Windows NT 3.1) (Windows Vista)
  • 5. Increasing Software DemandDemand for software is skyrocketingMore and more “traditional” tasks are beingassisted or replaced by softwareToday, most consumer devices have some sortof software running inside. A growing trend.Disposable computing is not far away...
  • 6. Increasing ChallengesSoftware makers need to address the evolution in:- Compliance regulations (HL7, Sarbanes-Oxley, HIPPA)- Multi-core & Multi-threading- Development paradigms (SOA, Web 2.0, SaaS, cloud computing)And at the same time face:- Decreasing time-to-market- Decreasing budgets
  • 7. Software development is an ever-growing challenge... What have we done so far to address this?
  • 8. The “Software Crisis” “The major cause of the software crisis is that the machines have become several orders of magnitude more powerful! To put it quite bluntly: as long as there were no machines, programming was no problem at all; when we had a few weak computers, programming became a mild problem, and now we have gigantic computers, programming has become an equally gigantic problem.” Edsger Dijkstra, 1972 This was written almost four decades ago, but looks as it could have been written today.
  • 9. The “Software Crisis”Consecutive revolutions are being achieved in many domainsthanks to computer software. Increasing Increasing Increasing Demand Complexity Challenges Software Crisis Same Same Same Workforce Methods ToolsHowever, software engineering is not seeing the same evolutionrate as in the domains it addresses.
  • 10. Problem : Slow tool evolutionIn the seventies,people developed software line-by-line, file-by-fileFour decades later,most people still develop software line-by-line, file-by-fileWhile there has been some evolution in development methodsand tools, most are essentially based on flat source files.
  • 11. Problem : Same old methodsWaterfallFirst described in 1970, is still the most widespread development organizational method.“The waterfall model is argued by many to be a bad idea in practice, mainly because of their belief that it is impossible,for any non-trivial project, to get one phase of a software products lifecycle perfected before moving on to the nextphases and learning from them.”http://en.wikipedia.org/wiki/Waterfall_modelOne-Off DevelopmentEvery developed application is unique, started from scratch“The assumption of one-off development is so deeply ingrained in this industry that most of us are not conscious of eitherthe practice or the alternatives. Even XP* and UP** assume that every product will be designed and developedindependently from first principles to accommodate its unique requirements, and neither of them provides guidance forsupplying or consuming reusable assets.”Jack Greenfield, Keith Short – Software Factories *XP = Extreme Programming **UP = Unified Process
  • 12. Problem : Feature TraceabilityThe traceability problem occurs when the solution features that implement a problemfeature cannot be easily identified.This makes it hard to identify all of the things that need to change in theimplementation, and to ensure that all of the changes are made consistently, whenthe requirements change.Failing to trace all elementsthat belong to a given feature Whichleads to bugs, inconsistencies, ? Dataand excess time. FeatureIts a (too) common scenario. Source Specification Code
  • 13. Failed PromisesIn the recent past, several “promises” have emerged,claiming to be the silver bullet to the software crisis.But many have failed, or simply did not deliver.Let us have a look into the most important ones:(Quoting the opinion of others)
  • 14. #1 : UML – Unified Modeling Language“UML is applying an abstraction at the wrong end of the problem. It isprimarily used to sketch object models for inferior languages. As such,it tends to explode into incomprehensible patterns of accidentalcomplexity in order to accommodate the various “design patterns”that are used work around the lack of essential language features.Because the UML models cannot be compiled, executed, orinterpreted, they are reduced to the level of mere documentation. Assuch, it is generally not even worth keeping in sync– the manualround trip from the code to the model and back is just too expensivefor something that adds no more value to a project than an elaboratecode comment.”From lispy.wordpress.com “UML has become complex and clumsy. For 80% of all software only 20% of UML is needed. However, it is not easy to find the subset of UML which we would call the Essential UML”. Ivar Jacobson, Co-Inventor of UML, June 2009
  • 15. #2 : MDA – Model-Driven Architecture“At its most basic, MDA involves transforming one UML model into another UML model, possiblyseveral times and possibly automatically [...]. The MDA approach leads to the same results aswizards: lots of code (and models) that you didn’t write yourself but that you are expected tomaintain. The MDA idea gets even worse when you consider round-tripping—would you like toupdate the manually made changes to the code and lower level models back to all the higher-levelmodels?”Kelly / Tolvanen – Metacase“MDA is limited to the effectiveness of the UML as a language for model driven development,a task it was not designed to support.”Jack Greenfield - Microsoft“Unfortunately, early enthusiasm for Model Driven Architecture (MDA) has dissipated to thepoint that many people are openly skeptical of the value of any model-driven approach.”From “MDA Redux”, by Alan Brown, published by IEEE Computer Society
  • 16. #3 : DSLs - Domain-Specific Languages“[...] the Tower Of Babel* effect that results from having so many languages that a person needs tobe familiar with (if not master) in order to get common jobs done.”“... nothing is better than having your own Little Language to do a specific job. It allows for conciseexpression of solutions to specific problems. But a problem arises when The Next Guy comes alongand has to learn the concepts behind the language, the motivations for particular elements of it,the syntax, etc.”“Writing a decent DSL is hard. Very limited, very simple DSLs can be adequately produced by acompetent programmer with expertise in the problem domain - DSLs that can be described on apage or two, and are tailored to a specific application/environment. These language are seldomusable outside the very limited context.”“But writing a good DSL that is robust and reusable beyond a limited context, is a lot of work. Itrequires persons with both domain expertise and language design expertise (not necessarily thesame person) to pull off. A truly reusable DSL will require reasonable documentation, otherwise itwont survive the departure of its designers. And, it will eventually require a good set of tools -debugging environments and the like - for it to become worthwhile.”Taken from http://c2.com/cgi/wiki?DomainSpecificLanguage * http://c2.com/cgi/wiki?TowerOfBabel
  • 17. Gaining Momentum : MDSD and DSMUnlike MDA, MDSD (Model-Driven Software Development) andDSM (Domain-Specific Modeling) follow a more pragmatic, lessformal approach to software modeling. That makes theseapproaches more accessible to the mere developer.“Forrester expects model-driven development (MDD) to play a key role in the future of softwaredevelopment; it is a promising technique for helping application development managers addressgrowing business complexity and demand.”Diego Lo Giudice – Forrester ResearchDomain-Specific Modeling raises the level of abstractionbeyond programming by specifying the solution directly usingdomain concepts. The final products are generatedfrom these high-level specifications, because both the modeland generators fit the requirements of only one company anddomain. Your experts define them, your developers use them.
  • 18. PART IIABSE - OverviewHow can ABSE address todays software development problems
  • 19. Quick Facts ABSE- Stands for “Atom-Based Software Engineering”- Is a generative approach (generates code from models) toMDSD (Model-Driven Software Development) and DSM (Domain-Specific Modeling)- Relies on tree-based models AtomWeaver- Is a cross-platform Integrated Development Environment (IDE)- Implements and extends ABSE
  • 20. The ABSE TreeA software engineering project is made up of “Atoms”, organizedas a tree. That tree is the Project Model. A tree conveys association, mimicking the associative human brain, therefore being able to represent and decompose any problem or data structure. The tree is ABSEs supporting paradigm, allowing the model to “think” like us. < A partial view of AtomWeavers ABSE model
  • 21. Models in ABSEAn ABSE model, like in other MDSD methodologies, is abstractedat multiple levels: Atom ABSEs single meta-metamodel 1 * Atom Template Metamodels 1 * Atom Instance Models 1 * Text / Data Generated artifacts
  • 22. Atom TypesThere are only three types of Atoms:Atom Template → The metamodels (building blocks) of any ABSE modelAtom Instance → The actual models that make up a project modelAtom Organizer → Organizes library contents into meaningful structures
  • 23. Atom LibrariesAn Atom Library contains Atom Templates, possibly structured in ameaningful way through Atom Organizers.Any ABSE model must be built fromone or more libraries as it canonly contain Atom Instances. Root Lib Language Lib Solution DomainLibraries can use or extend Platform Libother libraries. Domain LibWe can raise the abstraction Problem Domainlevel everytime we extend Domaina library. Components Lib
  • 24. Atom LibrariesThe Atom Libraries are the driving force behind ABSE.A good library can help you save many development hours,and even more test hours.The vision behind Software Product Lines (SPL) is that once thecompanys domain is converted into models, they can bereused and combined to create similar, but different, systems.ABSE and its libraries help SPLs become a reality.Libraries can be exchanged between systems throughALX (AtomWeaver Library Exchange) files.
  • 25. ABSE is Universal It can support and combine all forms of software engineering, including: ● Traditional file-oriented methods Root Lib Literate Programming Higher Abstraction ● Language Lib ● Aspect-Oriented Programming Platform Lib ● Component-Based Development ● Feature-Driven Development Domain Lib ● Domain-Specific Modeling ● Software Product Lines Domain Components ● Software Factories Lib
  • 26. ABSE is UniversalThis is possible because ABSE...● … is not targeted to a specific language, architecture, or platform● … allows generation of any kind of text or data● … has a very flexible meta-metamodel● … uses association as its paradigm, the basis of human thinking
  • 27. ABSE is Domain-AgnosticABSE can be applied to virtually any domain. InternetHorizontal (solution domain) libraries can beextended with vertical (problem domain) Healthcarelibraries to achieve reductions in time-to-market and savings on development andtesting efforts. ScienceAtoms can represent and generate code forspecific aspects of the target domain. Embedded Devices Aerospace Enterprise Defense Systems Automotive Entertainment Engineering
  • 28. ABSE is Language-Independent Being largely based on text generation, ABSE can generate all kinds of textual output, from plain text files to complete software systems. A single ABSE project can target multiple languages and file types.FortranHaskellEiffelC#PhytonSQLJavaABAPErlangScalaSmalltalkVHDLPrologC++AdaPascalPHPLispRubyJavaScriptDelphiSASCOBOLCamlTclDVisualBasicCGroovyML
  • 29. ABSE is Refactorable Line-OrientedABSE metamodels can evolve with your skill. ObjectsYou can start doing just some texttransformation, grow up by refactoring PatternsMetamodels into common patterns.You can continue right up to full ComponentsDomain-Specific Modeling andSoftware Product Lines.Each time you derive an Atom Template into Domain-Specificanother Template, you increase theabstraction level. Software Factory
  • 30. ABSE is EasyYou dont need to be a rocket scientist to apply in an effective way.ABSE is accessible to the "mere developer mortal".An ABSE project is like a large mechanismthat can built from smaller, pre-built orcustom parts.The ABSE approach is more pragmatic and simpler than otherDSL/model-driven tools or technologies like oAW, OMGsMDA/MOF/XMI, Eclipse EMF/GMF, Microsoft OSLO/M, Xtext.
  • 31. ABSE is Complete source_file.hABSE meta-metamodeldesigned to support 100% atom_concept_a Generated codecode generation from themodel. Custom code Generated Model Transformation code Generated codeNo round-trip necessary. Custom code Custom codeThe mix of custom and source_file.cppgenerated code is directly atom_concept_bsupported by the meta- Custom codemetamodel. Generated code Custom Custom code codeNo worries about Generated codeoverwritten custom code, Generated codeno management issues.
  • 32. ABSE is ManageableAn ABSE model can grow togenerate multi-million lineapplications, and still be easyto manage.Thats because ABSE is based ona tree and not on a graph:Tree branches easily encapsulateother branches. A complex application using a graph
  • 33. ABSE is ComprehensiveThe complete ALM (Application Lifecycle Management)cycle can be supported.An ABSE tree is not exclusive to software implementation:it can also represent processes, documentation, SCM, etc. Documentation Project Bugs & Support
  • 34. ABSE is CollaborativeDue to its granular nature,an ABSE model can be Instance Aconcurrently manipulated. Instance BTwo or more developers canwork on the same ABSE model. Instance C Instance D Instance EAnd through a supporting tool(like AtomWeaver), workflows Instance Fcan be applied. Individual atoms Instance Gor tree branches can bechecked-in or out, versioned andconditionally enabled/disabled.
  • 35. PART IIIABSE in the EnterpriseHow can ABSE improve software engineering
  • 36. ABSE Can Bridge All StakeholdersBy making available the appropriate Templates to each stakeholder,domain experts, designers, developers and testers can worktogether on the same ABSE model.● Domain experts can specify● Designers can design & re-arrange● Developers can build● Testers can debug & test
  • 37. ABSE Captures & Shares KnowledgeThe companys domain knowledge and the teams developmentknowledge can be captured into ABSE metamodels.Benefits:- Individual expertise can be shared with the whole team- Less skilled developers can work like the experts- Architectural uniformity can be achieved- Best practices are easily disseminated and enforced
  • 38. ABSE Increases ProductivitySome tasks under manual coding simply cannot scale:- Repetitive patterns- Repetitive coding- Repetitive changes- Interfacing code/specification- Unit test preparation- Debug/log/trace codeThese and many other boring and error-prone tasks canbe reduced or even completely eliminated by using amodel-driven approach like ABSE.
  • 39. ABSE Increases ProductivityThe teams productivity potential increases whenever it addsanother metamodel (Atom Template) to the ABSE library.Working on a higher abstraction level boosts your productivity.Each time an ABSE metamodel is instantiated, time is saved.Each time an ABSE metamodel is extended, more time is saved.
  • 40. ABSE Increases Quality of Code It is known that more time is spent debugging code than actually writing it. The code produced by the ABSE metamodels can (and should) be tried and tested code. By reducing the amount of custom code used in the model, overall code quality increases.
  • 41. Critical Innovation : Software Reuse Systematic software reuse is a promising means to reduce development cycle time and cost, improve software quality, and leverage existing effort by constructing and applying multi-use assets like architectures, patterns, components, and frameworks.“To realize a return on the investments we make in developing the solutions, we must reuse themenough to more than recover the cost of their development, either directly through cost reductions,or indirectly, through time to market reductions and quality improvements.”Jack Greenfield et al - “Software Factories”
  • 42. ABSE Promotes ReuseThe most common type of reuse is the reuse of software components, butother artifacts produced during the software development process can alsobe reused: system architectures, analysis models, design models, designpatterns, database schemas, web services, etc.ABSEs meta-metamodel allows Atom Templates to be aggregators,so you can turn any part of your project into a new template forfuture reuse. Instance A Template 1 Instance D Instance B Instance A Instance 1 Instance C Instance B Instance E “Templatization” Reuse Instance C Instance F Project A Library A Project BIn the same way, ABSE lets you turn recurring patterns intotemplates, reducing project complexity and maintenance costs.
  • 43. ABSE Reduces Maintenance CostsWith ABSE youll haveless code to maintain. Traditional Approach ABSE ApproachThats because youonly have to maintain Manual Codeone instance of yourcode. All otherinstances of that codeare automatically Manual Code Codebase Sizeupdated. GeneratedAnd since manual code Manual Code Codeis natively supported, Manual Codetheres no need to Generated Codewaste time maintainingprotected regions,code guards and othertrickery, just to Atom Librarymaintain the integrity Atom Librarybetween manual andgenerated code.
  • 44. PART IVABSE - Technical OverviewA closer look into ABSE and how it works
  • 45. The Atom (ABSEs Meta-metamodel)The Atom can be root_default An Atom can alsoinstantiated into be compared to anAtom Templates. object in an object- oriented programming Base Template language.Atom Templatesderive from othertemplates. Atom Template Instantiation Atom InstanceAll Atom Templates Compositionderive from Admin Parameters Variablesroot_default, the Creationonly pre-existing Form Functions ConditionAtom Template in Transformation Custom Areas Custom CodeABSE. Code RelocationAtom Templates canbe instantiated into Derived TemplateAtom Instances.
  • 46. The Atom Admin Section Atom TemplateThe Admin Section of an AtomTemplate determines how its instances Admin Parametersare presented and how they behave Form Functionson the Model Tree. Transformation Custom Areas CodeOn the Admin Section you can define:- Icon and Label to be shown on the model- Construction constraints- Atom parameters- Other discovery and construction helpersThe Admin Section also inherits from its base templates.
  • 47. The Atom Form Section Atom TemplateEach Atom Template has a dedicatedEditor. Admin Parameters Form Functions Transformation Custom Areas CodeThe Form Section lets you define howthe editor presents the Atom TemplateParameters and how you can set thecorresponding Instance Variables.The Form Section also inherits from its base templates.
  • 48. The Atom Functions Section(and Behaviors) Atom TemplateThis section lets you define extra atom Admin ParametersFunctions. Form Functions Transformation Custom AreasThe most common use is to define CodeAtom Behaviors.An Atom Behavior is a powerful generalization technique: It allowsthe atom to respond to a specific, globally-defined query.Any atom can request processing from another atom withoutactually knowing its type, allowing unlimited future extensions.
  • 49. The Atom Transformation CodeThe transformation code allows any Atom Templateatom to perform actions based on itsinput parameters. Admin Parameters Form FunctionsMost common task is to generate Transformationcode, but other tasks like modifying Code Custom Areasother atoms and OS calls are alsopossible. The Atoms transformation code is segmented into the following steps: Create Pre Exec Post Code Code Code Code
  • 50. The Atoms Custom CodeTo support 100% code generation from Atom Templatethe model, and to avoid synchronization Admin Parametersproblems between generated andcustom code, ABSE allows you to define Form Functionsone or more custom code areas on an TransformationAtom Instance. Code Custom Areas java_function source_file.java int Function() parameter { generated code; generated code; parameter custom_code custom_code generated code; }
  • 51. The Instances Creation Condition Atom InstanceThe inclusion of each Atom Instance Variableson the project can be subject to an Creationexpression that dictates whether that ConditionAtom is executed or not. Custom CodeIf the evaluated condition is false, the RelocationAtom becomes invisible to the project.This brings more flexibility to thegeneration process and allows templatesto include/exclude some of their auto-generated atoms based on user-suppliedvalues.
  • 52. Instance RelocationAtom Instances that are auto-generated by Atom Instancean Atom Template can then be relocated to Variablesanother position on the model tree. Creation ConditionThe relocated atom may be again moved Custom Codeby the user, if it is not blocked. Relocation For instance, user interface programmers may create atoms that will automatically create the interface visual elementss atoms. Designers can then manipulate and edit those atoms to achieve the desired application visuals.
  • 53. ABSE Strength #1 : InheritanceLike classes in several programminglanguages, Atom Templates can bederived into more complex and root_defaultspecialized Templates. cpp_classThis allows you tobuild metamodelsthat share commonconcepts. gui_dialog ext_data_object db_persistent_objectThe derived template will inherit allproperties and code from its base template.
  • 54. ABSE Strength #2 : CompositionAtoms can be combined to build larger structures.Atom Instances are combined to build the Project Model.Atom Templates can be composed of several other Templates which,on their turn, can also be composed of other Templates. From Wikipedia: ext_powered_class http://en.wikipedia.org/wiki/Obje ct_composition Composited (composed) objects are often referred to as having a "has a" cpp_member cpp_method relationship. A real-world example of composition may be seen in an automobile: the objects wheel, cpp_member cpp_argument steering wheel, seat, gearbox and engine may have no functionality by themselves, but an object called cpp_return_value automobile containing all of those objects would serve a higher function, greater than the sum of its parts.
  • 55. Inheritance & Composition CombinedYou can see here how a metamodel of Actual metamodels from AtomWeaver projecta C++ class, composed of two AtomInstances, is derived into an“extended class” with addedfeatures. Then a C++ Componentmetamodel is defined byinheriting Extended Classand adding data andconfigurationfeatures...
  • 56. Inheritance & Composition Combined Then a Persistent Component metamodel was created by inheriting a C++ Component model and adding specific DB features. The same was done to create a Database Document metamodel.
  • 57. Inheritance & Composition Combined You can implicitly generate dozens or even hundreds of atoms just by adding a single atom instance to the project. If each of those atoms generates just a few lines of code... Imagine how much code that can be generated at once! Now imagine that the generated code is mature, tested, quality code...
  • 58. Atom Templates = Software ComponentsABSE lets you build applications like Lego . A simple, yet effective tmconstraint system drives you on the component discovery andconstruction process. Metamodels Constraints Correct Models + =
  • 59. ABSE is an Executable ModelEvery Atom on the ABSE Tree has its own transformation code(acquired from its template). To generate code, the Model Tree recursively executes its atoms, Execution Sequence which is equivalent to say that all atoms are executed from top to bottom. The tree is executed four times, and on each iteraction one of the following Atom Template sections is executed: Create Pre Exec Post Code Code Code Code
  • 60. Variable Transmission Atom cpp_class Defines: class_name, Variables are set on Atom inheritance Can access: ... Instances, and each variable corresponds to an Atom Template parameter. Atom cpp_function Defines: func_name Can access: class_name, inheritance Any variable from an Atom is automatically available to Atom cpp_argument all branch children. Defines: arg_name, arg_type Can access: class_name, Inheritance, func_name This way, any Atom can work “in context” with its Atom cpp_member ancestors. Defines: member_name, member_type Can access: class_name, inheritance
  • 61. PART VAtomWeaverAn ABSE Integrated Development Environment
  • 62. AtomWeaver is an ABSE ModelAtomWeaver is being developed through an ABSE Model.AtomWeaver is ABSEs proof-of-concept, showing that afairly sophisticated application can be easily built using amodel-driven approach like ABSE. Some statistics: (Current version of AtomWeaver Prototype) - 38000 Total Atoms - 7800 User-Created Atoms - 30200 Auto-Generated Atoms - 334 Atom Templates in Library - 2456 Atom Instances in Model - 174756 Lines of Generated (+ Manual) Code - 701 Generated Files
  • 63. Introducing AtomWeaver AtomWeaver implements and extends ABSE into a complete, agile, dynamic IDE. AtomWeaver prototype – AtomWeavers own ABSE model loaded
  • 64. Introducing AtomWeaverDue to ABSEs genericity,AtomWeaver works on anydevelopment environment,Integrated with any tool chain AtomWeaver is presently the markets only plug-and-play MDSD system No other present system lets you start creating models in a few minutes
  • 65. AtomWeaver : The Universal GeneratorBesides pure programming, Why use separate tools?the modern software vendorfaces a long list of other AtomWeaver can be the centralperipheral, but equally point of all development activities.important activities:- Requirement management Using AtomWeavers modeling and- Research generation capabilities, its- Change management surprisingly easy to:- Building- Testing - Build your own bug tracker- Version control - Implement code coverage- Issue management - Automate documentation- Internal/customer reporting - Build synched intranets/websites- End-user documentation- Code revisions - Create configurations/build files- Installer packaging - Package resources- Application resources - Automatically build tests- Databases - Embed debug/trace code- ... - Refactor features/architecture
  • 66. AtomWeaver ModulesAtomWeaver is composed of several mandatory and optionalmodules. Each module contains a different aspect of the project.Library, Model, Files and Log are the mandatory modules. Allothers are optional.Future AtomWeaver versions will allow the creation of other,custom-defined modules through its API.
  • 67. AtomWeaver ModulesDocumentation → For development support documentation, drafts, etc.Library → Contains all libraries loaded into the projectModel → Holds the projects main modelFiles → Lists and manages all generated artifactsIssues → Manages SCM operations (bug tracking as the most common)Help → Builds and concentrates all end-user documentationLog → Registers all that is happening in AtomWeaver
  • 68. AtomWeavers Model Transformation DSL: LuaInstead of using an exotic, custom DSL, AtomWeaver uses Lua totransform ABSE models into final source code.Lua is a lightweight, reflective, imperative and functionalprogramming language, designed to be a scripting language.Several benchmarks show Lua as the fastest interpreted scriptinglanguage available.This is specially important to code generation where millions oflines of transformation code are typically needed on a large project.
  • 69. AtomWeaver Extends ABSEAtomWeaver adds tools and commands to ABSEs basic featuresetto improve the developers experience and productivity, including :● Atom Dictionary : Lets you reference any project Atom byits associated name.● Atom Lists : Lets you categorize atoms and build lists accordingto your pre-defined criteria.● Counters : Lets you use unique values project-wide.
  • 70. AtomWeaver editionsTwo editions of AtomWeaver are planned: Solo Edition Team Edition For: For: - Individuals - Collaborative projects - MicroISVs - SMEs - Small projects - Large corporations - Isolated generation tasks - Research institutes
  • 71. AtomWeaver 1.0 feature matrix Feature Solo Edition Team Edition Code Generator, Interpreter, Rules Engine X X IDE X X Library Repository X X File-based Database Storage (SQLite) X Server-based Database Storage (MS SQL Server) X ALM (Application LifeCycle Management) Support X X Model Versioning X Developer Roles X Concurrent Model Edition X Workflows & Tasks X
  • 72. AtomWeaver estimated prices Solo Edition Team Edition USD $499 USD $999 Regular Regular, Per Seat USD $199 USD $499 Early Adopter Campaign Early Adopter Campaign Per Seat Prices not definitive, subject to change Optional support and/or maintenance not included
  • 73. AtomWeavers next major features The following major features are planned for versions 2 & 3 of AtomWeaver Flexible Diagramming Generic GUI Mockups Scripting API Any kind of diagram can be Mockups for any system will AtomWeaver will be created, following rules be possible using ABSEs scriptable, opening the door defined in Atom Templates generic constraint system. to user-defined ABSE and in the Library. Hybrid Programmers can program models, extensions, custom diagram/tree development while designers can design actions on atoms, and third- will be possible. and rearrange. party add-ons.
  • 74. The Library ExchangeAtomWeaver will have its dedicated Library Exchange site thatwill concentrate all publicly available Atom Libraries:- Free Libraries- Commercial LibrariesThese libraries can be supplied by:- Individual users- Commercial vendors- IsomerisBy using ready-made libraries, you save time and get qualitycode and models from the domain experts.
  • 75. Team Edition Feature:Concurrent Model EditionThe project is stored on a central databaseDevelopers can load a copy of the project into their workstationsAn Atom or a branch can be checked-out for edition. Other usersare denied write access to that atom or branchAfter check-in, changes are incorporated into the central databaseAtomWeaver regularly checks for new updates and automaticallyloads them to the local copy of the project
  • 76. Team Edition Feature:Developer Role ManagementThe structure of a development team is mimicked in theAtomWeaver environmentEach user must log in to work on a projectThe two main roles are Architects and Developers. Other rolescan be createdEach role can have different privileges regarding code accessor changesDeveloper roles are also useful for workflows
  • 77. Team Edition Feature:Model VersioningLike in a source control system, atoms can be versionedBranches/forks can be madePast project snapshots can be obtainedAtoms can be reverted to a previous versionDifferent versions of atoms or branches can be diffed
  • 78. Team Edition Feature:Workflows and TasksThe development process can be pro-actively managed byAtomWeaverAll processes are defined by the organization through Atoms,stored as librariesWorkflows, tasks and memos can be issued.Activities like testing, change requests, code reviews, etc. canbe implementedAtoms can be selected & associated to these activities
  • 79. AtomWeaver release timeline* Apr.2011 : AtomWeaver Team v1.0 CTP Dec.2011 : AtomWeaver Team v2.0 2010 2011 2012 Sep.2011 : AtomWeaver Solo v2.0Sep.2010 : AtomWeaver Solo v1.0 CTP May.2011 : AtomWeaver Solo v3.0 *Timings subject to change
  • 80. AtomWeaver CompetitorsCode Generation is a high-growth market segment: Thereare currently dozens of competitors.However, most of these products are specific to agiven domain, platform, or function.None of the other existing products todayis able to offer a technologicalinnovation that can be recognized asa true software developmentbreakthrough asABSE & AtomWeaverdo.
  • 81. PART VISummarySumming up ABSE & AtomWeaver
  • 82. ABSE aims to lead the MDSD movementMDSD is recognized as the next revolution in the SoftwareEngineering industry, and is gaining momentum among largerorganizations.However, complexity in its various implementations prevents itfrom gaining mainstream adoption. ABSE aims to lead MDSD adoption by: - Defining a very light meta-metamodel - Having a small set of rules - Being flexible (can mix custom and generated code) - Having a reference implementation (AtomWeaver)
  • 83. AtomWeaver aims to compete with otherhigh-end IDEsMS Visual Studio and Eclipse are the major players in thegeneral-purpose software IDE segmentAtomWeaver can differentiate itself by:- Its unique development approach (ABSE)- A high adaptability to very specific industries and domains- Having lower licensing costs
  • 84. Reality Check ! ABSE still in its infancy AtomWeaver is still just a bare-bones IDE Developer mindset inertia is a respectful opponent
  • 85. ABSE & AtomWeaver on the Internet www.twitter.com/atomweaver community.atomweaver.com www.abse.info www.atomweaver.com www.ruicurado.com
  • 86. Thank you for your interest inABSE and AtomWeaver www.isomeris.com