Tue, 22 January 2008 |
|
Wed, 15 August 2007
Hosts: Michael and Markus
This episode is an introduction to embedded system. It is an introduction
in the sense that we cover many topics very briefly: upcoming episodes will
provides details for many of these topics.
We start by discussing what an embedded system is an what the important
characteristics are. Among them is limited resources, concurrency, real
time and hardware integration. We also discuss the range of embedded systems from
small mirocontrollers to mobile phones to distributed real time embedded
systems. We also cover the different business case for embedded systems
(per unit cost) and some non-trivial developmental aspects (cross compilation
debugging, heisenbugs).
We close the episode by discussing some important architectural styles
(time triggered, event-based, microkernels, state machines) as well as
tools of the trade: languages, operating systems and middleware.
Publicize:
Digg this
Post to del.icio.us
Post to Slashdot
|
|
Wed, 6 June 2007
Hosts: Michael and Markus
Variability is one of the key concerns in software product line engineering. The episode introduces the concepts of structural and non-structural (or configurative) variability. It also discusses how to find and model variability, and especially how to implement variability in the solution artifacts. Michael and Markus discuss a series of variability mechanisms that can be used with today's programming languages and technologies.
Publicize:
Digg this
Post to del.icio.us
Post to Slashdot
|
|
Mon, 7 May 2007
Hosts: Martin and Eberhard
In the first episode on Refactoring we talked about the basic ideas behind refactoring and some base principles why refactoring is a key part of software engineering. Now we move on to more complicated refactorings and discuss three major situations, their problems and possible solutions: advanced refactorings in large projects that can hardly be finished in a few minutes or hours and refactoring in larger teams. Also covered are the refactoring of published APIs and how merciless refactoring could be aligned with backward compatibility of published APIs, and refactorings that affect more than just code like for example database schemas.
Publicize:
Digg this
Post to del.icio.us
Post to Slashdot
|
|
Tue, 17 April 2007
Hosts: Michael and Markus
Michael Kircher and Markus Voelter introduce the topic of software product line engineering. They motivate when and why product lines are important to consider and what makes them so special. Further, they introduce some key terminology, such as platform, core asset, feature model, commonality, and variability.
Publicize:
Digg this
Post to del.icio.us
Post to Slashdot
|
|
Wed, 28 March 2007
Hosts: Arno and Michael
In this episode, Arno and Michael take a look at Design by Contract, a programming technique formalized by Bertrand Meyer. The idea is that an interface is more than method signatures - it is also about specifying the expected behavior that implementations must provide. While some languages include direct support for this
style of programming, it is a useful mindset when desiging interfaces even without such language features.
Publicize:
Digg this
Post to del.icio.us
Post to Slashdot
|
|
Fri, 16 February 2007
Hosts: Martin and Eberhard
Changeable software has been a goal of several technique in software engineering. Probably the most important is Refactoring, changing the code without changing the behaviour (or at least without breaking the tests). In this episode Eberhard talks with Martin Lippert about this technique. The episode covers a history of refactoring, a definition of code smells and how to actually do refactorings in your everyday work. Also some advanced topics - like the ROI of Refactoring or Refactoring in dynamic languages - are covered.
Publicize:
Digg this
Post to del.icio.us
Post to Slashdot
|
|
Wed, 17 January 2007
Hosts: Arno and Alex
This is the second part of our two part discussion of the eXtreme Programming development methodology. While the first part introduced the values, principles and basic practices, this time Arno and Alex speak about the practices that set the context for an XP project and how to get started, and they discuss some FAQs they often get when introducing XP.
Publicize:
Digg this
Post to del.icio.us
Post to Slashdot
|
|
Wed, 27 December 2006
Hosts: Michael and Markus
This is the fourth and final episode on the fundamentals of Software Architecture. We talk mainly about architectural styles and patterns, as introduced in the POSA 1 Book. We also discuss a little bit the process of actually using those patterns for architecting systems.
Publicize:
Digg this
Post to del.icio.us
Post to Slashdot
|
|
Sat, 18 November 2006
Hosts: Arno and Alex
This is the first of two episodes where Arno and Alex discuss eXtreme Programming in se-radio's development process track. eXtreme Programming (XP) revolutionized the way of thinking about software development methodologies and helped to make the agile movement popular. In this episode they discuss the very basics of XP, its value system, principles and the basic practices used in an XP project.
The second episode will continue the introduction adding the missing practices and how to introduce XP into projects.
Publicize:
Digg this
Post to del.icio.us
Post to Slashdot
|
|
Mon, 23 October 2006
Hosts: Markus and Eberhard
This is the second snippet of the SOA 2 double-episode. Eberhard and Markus continue the discussion with the issue of service reuse and a couple of development process issues. We also look at the duality between infrastructure development and application development in the context of an SOA. We then discuss the great spaghetti misunderstanding :-). We conclude this episode with a look at how to integrate BPM into the conceptual SOA framework we've built up to now, and we'll also briefly skim over a number of technologies related to SOA.
Note that this episode, as well as the last one, is based on a set of slides; these can be downloaded from here. This episode covers slides 39 through 74.
Direct download: seradio-episode33-soa_pt2b.mp3 Category: regular/technology -- posted at: 7:14 AM |
|
Fri, 13 October 2006
Hosts: Markus and Eberhard
In this, as well as in the next episode Eberhard and Markus continue their discussion about SOA (the episode got too long, so we had to split it into two ... SOA 2a and SOA 2b). In this episode, we talk about the various perspectives on SOA (CBD, EAI, BPM), about fundamental requirements towards an SOA, and we discuss the role of models in defining sustainable architectures. We also discuss how a programming model based on the described approach typically looks like. We then discuss a number of issues any large-scale SOA faces (and for which the SOA paradigm does not really provide an out-of-the-box solution: In this episode we discuss data type ownership and (weak) typing of data types.
Note that this episode, as well as the next one, is based on a set of slides; these can be downloaded from here. This episode covers slides 1 through 38.
Direct download: seradio-episode32-soa_pt2a.mp3 Category: regular/technology -- posted at: 12:13 AM |
|
Sat, 23 September 2006
Hosts: Michael and Markus
In this third Episode on software architecture, Michael and Markus talk about the basic tools that an architect uses when architecting systems. These tools include things like separation, abstraction, compression and sharing. We also relate these tools to the quality attributes we introduced in previous archtecture episodes.
|
|
Wed, 13 September 2006
Hosts: Michael and Alex
The third part of our concurrency series by Michael and Alexander discusses how to build highly scalable servers. The discussion focusses especially on event-driven servers. As possible solution patterns a reactor-based design is suggested along-side several patterns for multi-threading issues: Reader/Writers Locks, Thread Pools, and Leader/Followers. For more information, see the references for part one, as well as the following links:
|
|
Sun, 3 September 2006
Hosts: Eberhard and Arno
In recent episodes we have discusses statically and dynamically typed languages and domain specific languages - topics that are much talked about in the community at the moment. In this episode we look at the foundation of programming languages : types. We explain what a type actually is, how type systems work and what polymorphism works.
|
|
Thu, 24 August 2006
Hosts: Markus and Eberhard
SOA (Service Oriented Architecture) appears to be just another hype - after all we have been building distributed systems for quite a while now. But the real value of SOA is non-technical. In this episode Eberhard and Markus discuss the advantages and disadvantages, what SOA actually is and how it compares to other approaches that have been tried out before.
Direct download: seradio-episode27-soa_pt1.mp3 Category: regular/technology -- posted at: 12:24 PM |
|
Fri, 4 August 2006
Hosts: Markus and Michael
In this Episode, Michael and Markus continue the discussion about the fundamentals of software architecture (we're doing it without Alex, because it is really hard to find a suitable time for all of us on the phone :-)). We talk about the various quality attributes (such as performance, scalability, maintainability and many more) and how they relate to each other.
|
|
Tue, 25 July 2006
Hosts: Arno and Alex
In this episode Arno and Alex talk about the basics of software development processes. They discuss why and when software development processes are needed and also why some developers don't like them. They discuss the theories behind different processes and talk about defined vs empiric processes in general. This episode is the first in a row that will later on describe specific processes like eXtreme programming or the unified process.
|
|
Sat, 15 July 2006
Hosts: Alex, Michael and Markus
This is the first of a series of Episodes on Software Architecture. Alex, Michael and Markus talk about rather fundamental topics in this episode, we'll go into much more detail in subsequent episodes in that series. Topics in this episode include:
- What is architecture, how is it different from design
- what different kinds of architecture are there in addition to software architecture
- the role of the architect, do we have one or more?
- architecture in agile software development
- tasks of the architect
- architect vs. the technical project lead
- architecture and project politics
- architecture requirements, estimating, team assembling
There aren't too many good references for this general architecture discussion. You might want to take a look at Software Architecture in Practice by Len Bass, or, if you speak German, at the book Software-Architektur by Vogel, Arnold, Chugtai, Ihler, Mehlig, Neumann, Völter and Zdun. |
|
Wed, 5 July 2006
Hosts: Michael and Arno
In this Episode, Arno and Michael take a closer look at Exceptions and
Error conditions, how to categorize them and how to deal with them. We look at the different levels of guarantee that a piece of code can provide with regard to exceptional condition and finish with a
discussion of a number of best practices and their respective trade-offs.
|
|
Thu, 15 June 2006
Hosts: Michael and Alex
In this second part of our concurrency series Michael and Alexander talk about basic patterns for concurrent programming, such as Active and Monitor Object, Scoped Locking and Futures. Further, they discuss some architectural considerations regarding the number of threads and resource usage in general.
For more information, see the references for part one as well as the following links:
|
|
Tue, 16 May 2006
Hosts: Eberhard and Markus
A very important area for Java are Enterprise Systems.
With the advent of new technologies like Ruby on Rails,
Java EE 5 or EJB 3 the landscape for Enterprise Systems
appears to be changing a lot at the moment. In this
episode Markus talks with Eberhard about what Enterprise
Java actually is, why and where it is used. Based on that
they discuss what the future might look like and how
to make Enterprise Java shine in the future.
|
|
Wed, 19 April 2006
Hosts: Alex and Michael
This is the first part of a series of Concurrency episodes. In this part Alex and Michael motivate and introduce the topic.
We explain fundamental terms, such as thread, process, or mutex and dicuss typical challenges, such as deadlocks and race
conditions.
Here are some related links:
|
|
Thu, 30 March 2006
Hosts: Michael and Markus
This is the second part of the remoting infrastructures discussion started in Episode 9. We take a look at how remoting infrastructures such as CORBA, .NET Remoting or Web Services work internally. This includes the low level details of the transport layer, marshalling, client proxies as well as interceptors and asynchronous communication. At the end, Michael will explain how all this relates to CORBA and Markus will map the concepts to .NET remoting. We don't have additional links in these show notes since all the relevant links had been posted for Episode 9 already.
|
|
Mon, 20 March 2006
Hosts: Michael and Markus
This Episode as well as the next one take a look at remoting infrastructures such as CORBA, .NET Remoting or Webservices.
In this first part we will take a look at why remote communication is necessary in the first place, what remoting middleware
can do for you as well as which other middleware technologies exist in addition to OO-RPC systems, such as messaging middleware. Finally, we conclude with a brief overview of what the broker pattern can do for us
in the context of remoting middleware. Here are some links you might find useful:
Note that this episode also contains listener feedback in the second part. You should listen to till the end,
since we have a free book to give away - details in the show.
In the next episode we will take a deeper look at remoting middleware based on our patterns. |
|
Tue, 28 February 2006
Hosts: Arno and Markus
This week, Arno and Markus take a look at error handling at the architectural level. They discuss the different kinds of errors, the groups of people who need to know about them and proven high-level approaches. Later episodes will investigate more technical aspects of error handling, such as idioms for using exceptions or a discussion of checked vs. unchecked exceptions.
|
|
Sun, 19 February 2006
Hosts: Markus and Eberhard
After discussing some of the more technical aspects
of MDSD in the last episode, we take a look at other
important topics in this one. This includes some tips
on how to introduce MDSD into projects and how the
development process has to be adapted for this to work,
as well as a look at the return on investment for MDSD.
The relationship of MDSD and Agile software development
is also discussed. Finally, we take a look at offshoring
in the context of MDSD.
Direct download: seradio-episode6-mdsd_pt2.mp3 Category: regular/technology -- posted at: 12:02 PM |
|
Fri, 10 February 2006
Hosts: Markus and Eberhard
In this Episode, Eberhard and Markus provide an introduction to Model-Driven Software Development. Since the discussion turned out
to be too long, we separated things into two episodes, thus Episode 6 will be the second part of this discussion. In this first part we
disucsss core concepts of MDSD, the relationship to MDA, and hint at a couple of tools.
Direct download: seradio-episode5-mdsd_pt1.mp3 Category: regular/technology -- posted at: 3:28 AM |
|
Thu, 2 February 2006
Hosts: Alexander and Markus
In this Episode, Alexander and Markus talk about scripting languages. Topics include the definition of what a scripting language is, typical usage scenarios, performance issues, programming styles and IDE support. In later Episodes we will talk about more specific topics, such as dynamic typing, reflection, functional programming as well as specific languages such as Ruby. Here are a couple of links you might find interesting:
|
|
Thu, 26 January 2006
Hosts: Eberhard and Markus
Eberhard and Markus discuss the important topic of associations and dependencies
in this show. While OO languages provide direct support for subtyping, most don't provide a
first-class construct for other relationships between objects. The discussion elaborates on the
problem and looks at various remedies, most importantly, dependency injection. Here are a
couple of links to topics that have been mentioned in the show:
|
|
Sun, 22 January 2006
Hosts: Michael and Markus
In this episode Michael and Markus talk about patterns. Starting with some
of their "most used" patterns, they go into some detail about the history
of patterns. They then discuss the various pattern forms as well as some
misconceptions about patterns. Other topics include the domains that are
covered by patterns as well as pattern languages.
Here are some links that you might find useful:
Direct download: seradio-episode1-patterns.mp3 Category: regular/technology -- posted at: 12:00 PM |
|
|
|
Note that the this page shows only the 50 most recent episodes. If you want to see older episodes, you
need to select the appropriate months from the archives.
|
|
Donate
|
Donate some money so we can buy additional audio equipment and
improve our sound quality.
|
|
Syndication
Spread the Word
Help us advertise for SE Radio by putting
logos on your website or posters into your
office.
Get materials here!
License
Please Vote for us!
Go To ...
Categories
Archives
About the Team
Donate
Search Audio/Notes
Thanks
Other Podcasts
Related Links
SE
Radio is (and will continue to be) an
independent and non-commercial endeavor.
Nonetheless, we want to say 'thank you'
to the following organizations who help
us to publicize the SE Radio podcast.
Categories
- all -
about/news/feedback
code/technology
guest/technology
interview
interview/roundtable
notifications
podcasts
regular/technology
Archives
January
February
January
February
March
April
May
June
July
August
September
October
November
December
January
February
March
April
May
June
July
August
September
October
November
December
Team
This podcast is brought
to you by a team of experienced software
developers and architects. You can reach
the team through
Search
Search in Show Notes:
|
Search in Audio Content:
|
|
|
|
| Search Google: |
 |
|
|
Thanks...
Other Podcasts
Some interesting podcasts you might want
to subscribe to:
Security Now!
Java
Posse
This Week in Tech (TWiT)
Futures in Biotech
IT Conversations
TED Talks
HPI Podcast
Tonabnehmer (German)
Manager Tools
Software
|
