text:
Production, reporting and media planning in one solution
What it is
The Evogenius product suite is a software solution that gives valuable insights into today´s media usage and television viewing habits.
How it works
This sophisticated solution from GfK handles everything from panel setup and data production through to data analysis and visualization. Each module is applicable individually or in combination with another Evogenius product. This is possible due to a uniform database.
Evogenius includes tools for each research requirement within an audience measurement operation. All media usage data can be processed, reported and evaluated using this powerful platform.
It contains customizable production software, a reporting tool that is intuitive to use, as well as an advertising tool that provides support throughout a campaign planning process and includes future usage behavior forecasting.
Evogenius is GfK´s comprehensive answer for international audience measurement operations and offers appreciable benefits to national and international Joint Industry Committees, broadcasters, TV Stations, airtime marketers and media agencies:
Our Business
We are a competence center for media research and providing media software tools and related services on an international level. We are dedicated to meet your country specific needs and requirements on your media project in terms of data and reporting options.
The GfK Evogenius product suite fulfills its optimal use in the field of audience measurement and is already introduced in different european countries both for TAM business and also on the reporting and media planning side of evaluation TV usage data.
Nevertheless the Evogenius products are also adaptable for data production and reporting processes outside the media sector. Both, our team for concept requirements and the development team are dedicated to meet your demands on processing usage data also for other areas of operation.
In the 21st century media dominates the population's day-to-day life. At home or at work, whatever people do, they are accompanied by media. The GfK Evogenius product suite is designed to suit all and more demands and tasks to execute audience research in general and Television Audience Measurement (TAM) in particular. Each singular Evogenius product offers a complete solution, measurement technologies, comprehensive data production processes, research expertise and analysis systems. Do you have to produce and process huge amounts of data? Are you looking for options to automize production processes? Do you need to analyse and visualize usage data?Benefit from our knowledge about international media research activities to support you in concepting and software engineering to find the perfect software solution for you!
In Germany GfK Fernsehforschung, which holds the Television Audience Measurement (TAM) contract for the Arbeitsgemeinschaft Fernsehforschung (AGF) for more than 20 years now, operates its data production with the Evogenius Production Manager since 2009. The panel consists of 5,000 households, which has been equipped with the meter unit UMX to measure the TV usage on the highest technical standard including lastest technologies like time shifted progam consumption and audiomatching.
In Portugal the TAM business is operated by GfK Portugal on the behalf of the Joint Industry Committee (JIC) CAEM since 2012. Here a complete set up of all required hardware, server and UMX meter unit installations to measure the TV consumption in the 1,000 panel households took place. Since March 1, 2012, Evogenius provides the currency in the Portuguese market.
Signing a contract with four of Brazil's leading broadcasters we are going to bring our innovative audience measurement experience to life in South America. By using our unique measurement service, we provide broader sampling in the 15 largest cities in Brazil, including viewers of terrestrial, cable and satellite television. The new system will be installed in 6,000 households across the country and will allow clients to convert smart data and analytics into meaningful insights for decision making.
Since January 2014 the TAM system in Lebanon has been launched. Our state-of-the-art technology to measure live and time-shifted TV consumption in 440 homes across the country comes into effect. The service is based on an electronic system called TV Logger which covers the basic functions of the broader UMX meter units.
Most recently GfK has signed a contract with Saudi Media Measurement Company (SMMC) to introduce a new television audience measurement service in the Kingdom of Saudi Arabia. We will set up the first-ever electronic TAM system in the country, based on a panel of 2,000 households which will be equipped with the technology Universal Meter System.
GfK Evogenius Product Suite
Within an international cooperation we provide the software package Evogenius which is composed of production-, reporting- and media planning. Other customer specific software solutions can also be based on Evogenius. Evogenius consists of the following four main applications deployable either as a powerful software package, or individually as a solution easy to embed into existing software architecture for television audience research:
GfK Evogenius Production comprises several tools to control and maintain the various steps of the daily data production and panel maintenance. Within our product portfolio the Evogenius Production Manager (EPM) is the application for daily data production, administration and panel maintenance. The software provides a comprehensive range of functions, used to monitor essential background processes.
The Evogenius Production Manager enables the user to process a great number of operations on stored data, from easily manageable administrative tasks to complex inquiries to the database. More information on Evogenius Production.
GfK Evogenius Reporting is a powerful and up-to-date software tool for the evaluation of usage data. It is designed to meet the demands of the market and offers many thematic and technical innovations for a variety of users. Evogenius Reporting answers all relevant research questions in the evaluation field and allows the evaluation and processing of usage data in tabular and graphical form. More information on Evogenius Reporting.
GfK Evogenius Web is the Result Viewer of the Evogenius product family. It was designed to give authorized users access to prepared research results, although they do not have an evaluation software. The update with new data is done by an automated process. The results presented as tables and graphs can be customized per user and are available to him online.
Evogenius also offers an evaluation package, designed specifically for the demands of the advertising market. This application package is called GfK Evogenius Advertising. With its modules Evogenius Advertising covers the whole range of possible requirements regarding forecasts, campaign planning, tracking and post control. More information on Evogenius Advertising. The Evogenius tools are complementary as they are all based on the same database but can also be used individually.
Our Services
Regardless the solution you choose - the whole product suite or single tools - you can rely on us! Evogenius clients always benefit from a comprehensive service portfolio.
Our flexible evaluation software tools reflect the latest developments of the international media research markets and incorporate the uniqueness of local requirements at the same time.
Our support hotline can be reached from Monday-Friday from 9.00 a.m. to 5.00 p.m. (CET) excluding German public holidays T: +49 911 395-2244
Of course, you can also contact us by E-Mail at: evogenius.support(at)gfk.com.
Training courses expand your knowledge concerning the methodology and technical conditions. We provide individual trainings via web session and also in face-to-face training courses.
Customized solutions make Evogenius so special.
We design the software solution for you according to your requests and market conditions.
If you switch from another TAM system to Evogenius you can count on the support of GfK. We analyze your data and workflows and assess the impact on the established work processes. For a smooth changeover, we assist and support you on-site during Migration.


text:
Totally Weird
Thursday, October 27, 2011
Let's see, weird headache, numbness in the face, eye droop......means call the doctor! They couldn't get me in, not sure why I didn't call 911, but I ended up in Urgent Care. They promptly transferred me to the hospital emergency department for a stroke evaluation.
As soon I got to the hospital, there were people all around me. Questions, needles, medications, and more questions.
Then the ED doc came in, she'd been reading my chart, and asked if I had a psychiatrist. WTF?
"Uh, yeah," I said while thinking, "what in the hell does that have to do with a possible stroke?"
"Well, good, but I want to assure you that I don't think this is a psychotic episode."
Well no shit! It's funny when they look in my chart the first thing they go to is "bipolar" and think I must be experiencing something psychotic. BULLSHIT!
Then there were CT scans, with and without contrast, x-rays, cords, machines, everything they could think of. In between all that excitement there were two shots of Dilaudid. That shit's satanic!
After all the narcotics I really couldn't understand what anyone was saying, but I remember them trying to give me the "touch my finger, touch your nose" test and I failed miserably, no shit, I was totally wasted at that point. That's when they told me they were admitting me to the stroke unit to be monitored.
When I got settled in a room I kept hearing all this shouting. It was coming from doctors and nurses. I remember asking the kids why everyone was so loud in the hallway. That's when they informed me that all the patients in the unit were well over a hundred years old and probably deaf.
Then it hit me.....possible stroke.....well over a hundred....OMG! I've never felt old before, but I sure as hell did then.
After awhile the doc came in, said my scans all looked good and said he wasn't sure what happened. It could have been a TIA, but he wasn't sure. Awesome. Good scans, doc not sure. Not feeling so great about things at that point.
So what's next? Doctor's appointments all day yesterday, one tomorrow and three on Monday. I guess we'll know more in the next few days.
Until then I'll just wait and try not to feel so old.
Read more...

subset: commoncrawl


text:
Hey all
I have two problems.
Number 1: I installed Mandrake 2006 dual config with my xp prof machine. When my computer boots up it goes straight to Mandrakes screen and gives me 4 options.
I made mandrakes partition around 10 gb on my first HDD where my Xp partition is. I now want to remove mandrake and just have windows. How is this done.
Number 2. I donloaded a .skn file for outlook 2007. The black skin. Which location do I copy this too? How do I get it going with outlook2007.
You can skype me on ciderza
or reply here.
Thank you all.


text:
Read latest COVID-19 advice for parents and childcarers here
Start by entering your postcode to set up your FREE
account and read reviews about childcarers local to you.
You can then book childcare online – just select the
date, time and address for your booking.
Choose the local carers you'd prefer us to offer your bookings
to first and we'll keep you updated of progress by email.
Your childcarer will call you before the booking and you should pay
her for her time at the end. Rates start from just £8.75.
Pay nothing until after you have used Sitters - guaranteed. A booking
fee (£4-£6) and quarterly membership fee (£14.95) will only be
charged to your credit card after your booking has taken place.
Read reviews of approved Sitters local to you
Susan was fantastic, calm and so experienced. The children took to her at once. She even came with her own brilliant childrens books and toys. We were staying in a rental house for the weekend so didnt have alot of toys/book resources. She was caring, confident and very safety aware. My twins loved her. She became part of the extended family. I cant recommend her enough. She was polite and so gentle with us all. She made us feel nothing was too much. I hope she enjoyed it as much as we did having her with our children for over 5 hours of full on child care. One brilliant lady.
We had never had anyone babysit for us that we did not know before booking Susan to look after our two sons (both under 5). We had experience of Sitters through friends who were incredibly positive about their experiences. Susan bonded immediately with our two sons and put us and them at ease. She is very friendly, polite and relaxed in her manner and at the same time professional. There is no question that we will book her again. Our experience absolutely matched our hopes and expectations. Thank you Susan and Sitters.
Georgina worked for us for the first time last night; she has made a very positive impression. She was punctual, listened clearly to instructions, had her own set of questions & immediately engaged with our son. He did not require a lot of play time before being put to bed, but Georgina followed our request to have some play time and get him to bed early. She has a pleasant manner in dealing with both of us and our little boy. We would be happy to have her back. Thank you for introducing her to us. Anthea Morland.


text:
Sunday, March 15
Phil Mickelson Is Wire-to-Wire Winner
Phil Mickelson at the Ryder Cup. To his right are Justin Leonard, Paul Azinger and Butch Harmon. (Proforged/Flickr)
"BEWARE THE AILING GOLFER," Phil Mickelson said in the press tent after claiming his first World Golf Championship title on Sunday at the Blue Monster in Miami, Florida. It was Phil's second win of the season and 36th career victory, trying him for 12th on the all-time win list with Lloyd Mangrum.
Lefty overcame a virus that prevented him from eating for two days and landed him in a clinic on Saturday night to be treated for dehydration. He also survived the splendid shotmaking of up-and-comer Nick Watney, who played in the final group with Mickelson in the last two rounds and left a tying putt inches short on the 72nd hole.
Phil carded rounds of 65, 66, 69 and 69 for a 19-under total. It was an impressive performance and will surely get the golf world buzzing about a possible Tiger-Phil duel, especially as the Masters approaches.
Bradley Wins in Puerto Rico
Michael Bradley sank an 11-foot birdie putt on the final hole to win the Puerto Rico Open.
−The Armchair Golfer
1 comment:
- Heather Kerrigan said...
What a blast to watch. After that 12th hole I wasn't sure how it would all end up, but they both played some spectacular golf. I thought it was fitting that both of their first putts on 18 landed on the edge of the cup. It was that close.
Cheers to Phil for being able to play when sick. I can't play well with a headache!
Subscribe to: Post Comments (Atom)


text:
JoBananas Body Jewellery
Due to the current situation in the UK and the threat to the health of staff and their families we are now closed for shipping of new orders until further notice.
Competitively Priced Body Piercing Jewellery With Friendly Service and Fast Shipping.
JoBananas have been selling body jewellery online in the UK and worldwide since 2001. Our range of body piercing supplies covers all materials such as Titanium, Surgical Steel, Black PVD, Bioplast, BioFlex, Wood and Bone. We cover all the popular body piercing jewellery ranges from Belly Bars, Tongue Bars, Nose Rings through to a great selection of Ear Stretching Jewellery inc Flesh Tunnels and Flesh Plugs. We also have a great collection of Tapers, Claws and Stretchers in many materials and designs. Bioplast and BioFlex labret studs and clear piercing retainers and hiders are also available for wear at work, school or for medical examinations.
We stock a huge range of Rose Gold Body Jewellery - Check out our 18k Rose Gold Plated body piercing jewellery
All of our body jewellery is in stock and we aim to despatch your order either the same or next business day. JoBananas Body Jewellery anodises (Titanium Colouring Process) and Gold Plate all of our jewellery in house. We have a unique range of Gold Plated Body Jewellery.
We offer FREE WORLDWIDE DELIVERY / SHIPPING on all orders over £10
For upper ear cartilage piercings we have Tragus Bars and Tragus Studs in plain or jewelled finish.
The latest trend is in Septum Piercing. JoBananas have Hinged Septum Clickers and Hinged Segment Rings in plain steel, Titanium and Gold Plate.
Huge choice of decorative nipple rings and nipple bars, labret studs and fashionable navel or belly button rings.
JoBananas stock the latest trends in piercings such as Septum Clickers and Nipple Clickers and internally threaded micro piercing jewellery.
If you need more information about body piercing and what types of piercings are available and what piercing jewellery fits them, then take time to check out our piercing guides for more detailed information. Also check out the Piercing Aftercare section on how to look after your new body piercing.


text:
By John Ulliman
By Tommi West
24 August 2009
24 August 2009
Prerequisite knowledge
A basic understanding of the Flash animation techniques described in the article, Creating a simple animation in Flash. Also read Creating a simple document in Flash if you are brand new to Flash and need a quick overview of its core features and workspace.
User Level
Required products
Sample files
- motion_editor.zip (399 KB)
Adobe Flash CS4 Professional includes some incredible new features that enable you to create complex animations with precise control and minimal effort. In this article, we focus on using the new Motion Editor, which lets you quickly tune motions, transformations, color effects, and more.
Setting the keyframes
To get started, download the sample source files linked to in the Requirements section above. Launch Flash CS4 Professional and open the sample file named car.fla (see Figure 1). To contrast the workflow between Flash CS4 and previous versions, let's make a simple animation with the car movie clip using the Timeline first.
To make the car drive onto the Stage, create a motion tween for the movie clip, move the playhead to the end of the tween, and then drag the car onto the Stage to set up the property keyframe. Scrub the playhead to watch the standard animation of the car driving in. Then choose Edit > Undo several times to remove the tween and revert back to a single keyframe on frame 1.
Now let's try this using the Motion Editor instead. Let's begin by setting the keyframes. Choose Window > Motion Editor to open the panel. By default, the Motion Editor docks with the Timeline. The following message is displayed: "To edit properties, select a tween span in the Timeline or a tweened object in the document."
Select the car and either choose Insert > Motion Tween or right-click (or Control-click) and choose Create Motion Tween from the context menu. Add a frame to the end of the background layer to make the two layers the same length.
The Motion Editor panel displays all the properties that can be tweened: basic motion, transformations, color effects, and more. The dotted lines on the graph indicate that there aren't any animations yet. The red bar is the playhead, which you can drag around to different locations just like the Timeline (see Figure 2).
Figure 2. The Motion Editor panel contains many settings, so you may want to resize it to see all the options.
Set the playhead at the end of the tween and move the car horizontally onto the Stage. The keyframes are set just as they are in the Timeline, but now the Motion Editor displays a solid line that indicates the motion of the car in the x direction.
On the left side of the panel, you'll notice that the X and Y properties are shown as numbers representing the pixel locations, similar to the Property inspector. If you hover over them, you'll see the arrow cursors indicating that you can click and drag in either direction to change the numbers.
On the graph, the keyframes are represented with black squares. To the left of the graph, you'll see the keyframe icons: arrow, diamond, arrow (see Figure 3).
Figure 3. The keyframe icons in the Motion Editor give you more precise control than you have with the Timeline.
The arrow icons enable you to jump the playhead from keyframe to keyframe. The diamond icon in the center enables you to insert keyframes at the current playhead location or delete a keyframe if one already exists at that spot. You can insert and remove keyframes using the Timeline, but the process requires a lot of dragging and right-clicking. Also, the Timeline displays a diamond representing a keyframe property change, but there is no indication which property it represents. The Motion Editor enables you to see exactly which property is changing as the object tweens.
Move the playhead and click the diamond icon to add and remove a few keyframes to see how much easier it is.
Making precise adjustments
Setting the keyframes is only the first part. As you review the sections in the Motion Editor, you'll probably notice the advanced ease controls. When you create animations in the Timeline, you have the ability to set a simple ease control on a tween, but you can only set a single ease value for each keyframe change, and only one type of ease is available.
The Motion Editor enables you to add a unique ease setting for each property that can be individually controlled.
Next to the X property, choose Simple (Slow) from the Ease pull-down menu (see Figure 4).
Figure 4. Choosing the Simple (Slow) ease setting doesn't affect the animation yet; you also need to adjust the value for the ease to specify the amount of slowing desired.
Scroll down to the bottom of the Motion Editor panel, and you'll see the Eases section. You'll see a setting next to the Simple (Slow) ease that is identical to the normal ease available from the Timeline. You can set this numeric value from –100 to 100. For this example, set it to 100 and test the movie. The car slows down at the end of the tween. This is the same thing you could have accomplished by applying an ease in the Timeline, but by making this change in the Motion Editor, you can now see the ease path of the car displayed in the Motion Editor graph as a purple dotted line.
Now here's the fun part. Return to the Eases section and click the plus (+) sign to see the entire list of available eases. To begin, choose the Simple (Fastest) option (see Figure 5).
Figure 5. The new ease is added to the Eases section, and it has its own settings to adjust the ease curve.
This curve is much steeper than the first, meaning the animation will slow down more dramatically than before. Return to the X property and use the Ease menu to choose the new ease you just set up. Test the movie. The car animation now has a much more dramatic speed change than before. It looks like the driver slams on the brakes much harder.
You can also use the Motion Editor panel to create the animations for both sets of wheels. Double-click the car to edit the movie clip. The front and back wheels are already on separate layers, ready to be tweened. The Motion Editor panel displays the message about selecting a tween span, so go to the Timeline and add two motion tweens for the wheel layers. Insert static frames for the car and driver layers, so they are all the same length, and then select the tween of the front wheel.
Return to the Motion Editor panel and direct your attention to the Rotation Z property. You'll see it is a flat dotted line, but you can move the playhead to the end of the tween and then adjust the rotation value to add a keyframe. When you do this, the graph moves to indicate the new motion applied to the front wheel. Try setting it to 360 degrees (or one rotation) as the car moves onto the Stage. Scroll down to the Eases section again, click the plus (+) sign, and add a Simple (Fastest) ease. You can adjust the value to match the ease used for the car (100). Notice that each object in the Motion Editor has its own custom ease settings.
Save time by copying the motion settings for the front wheel and applying them to the back wheel. Select the front wheel and either choose Edit > Timeline > Copy Motion or right-click (Control-click) and choose Copy Motion from the context menu. Select the back wheel tween and paste the motion—by either choosing Edit > Paste from the main menu or by right-clicking and choosing Paste from the context menu.
The Motion Editor offers so much more control over the little details of animations compared to working exclusively in the Timeline. You can apply different ease settings for different properties, add and remove keyframes in new ways, and see the complete picture of the movements applied to each tweened object.
Eases made easy
Now let's explore some of the other types of eases provided in the Motion Editor. When you click the plus (+) sign, you'll see that the four ease settings after Simple (Slow) are Stop and Start eases. These settings speed up the motion at the beginning and slow it down at the end.
Stop and Start (Fastest) is the perfect choice if you want the car to animate as shown earlier in Figure 1. To achieve this effect using the Timeline, you need to create two separate tweens—one at the beginning to speed up the car and another to slow down the ease. The Motion Editor simplifies this process because you can apply the advanced ease curve to get both ease effects on a single tween. Experiment with these settings by applying them to both the car and the wheels.
The rest of the eases in the list make it quick and easy to set up repeating or oscillating motions. To experiment with some of these eases, open the sample file named jack.fla.
The action of the toy can be created if Jack swings back and forth as he protrudes from the top of his box. You can accomplish this using the Timeline by setting up individual keyframe settings for the rotation tweens, or you can let the ease settings do all the work for you.
Double-click Jack to edit the movie clip. Create a motion tween for the Jack layer. Also add a static frame to the end of the box layer so that it does not disappear. While the tween for Jack is selected, return to the Motion Editor panel. Place the playhead on the first frame and adjust the Rotation Z value so that Jack is tilted to the left but still appears to protrude from the hole in the box (–16 looks good). Then move the playhead to the last frame and set the Rotation Z for the right side of the swing (29 works well). Test the movie (see Figure 6).
Return to the Eases section, click the plus (+) sign, and choose Sine Wave. Scroll back up and choose the Sine Wave option in the menu next to Rotation Z. Now Jack will swing back and forth, using the two keyframes as minimum and maximum values. You can adjust the speed of the swinging motion by assigning different numeric values to the Sine Wave curve. If you use an even number, Jack will complete a full swing before he repeats the loop.
Test the movie again to see the perfect motion for the swing. If you look closely, you'll notice that Jack even slows down a little at the end of each swing, which is a realistic touch. It's almost like Flash completed the hardest part of the animation for you.
Let's apply one more ease setting to the Y property. Return to scene 1. Select frame 1 of the Jack layer and create a motion tween. Then extend the background layer to match. Move the playhead to the last frame in the Jack layer and use the Selection tool to move Jack straight up in the air. This positioning sets the property keyframe for the Y value. Test the movie to see a bland animation of the vertical movement.
Return to the Motion Editor and scroll down to the Eases section. Click the plus (+) sign and add the Bounce ease. Use the menu next to the Y property to apply the Bounce ease setting. Test the movie again and see the difference. By applying a single ease setting, you've added a complete series of animation that uses the last keyframe's setting for the first bounce. And you have complete control over the way the toy bounces because you can adjust the numeric value of the bounce to set the number of bounces in the Bounce ease curve.
You can continue to experiment by moving the jack-in-the-box to the right to create a little X movement. In the Motion Editor, you can use the default Simple (Slow) ease for this property, and the jack-in-the-box will bounce across the screen as it wiggles its head. This example is really just the tip of the iceberg because there are so many cool motion effects and animations you can create by simply applying different ease settings to different properties in a single tween.
Now that you've taken a test drive and seen how easy it is to use the new types of ease settings, try adding the Custom ease setting and experiment by drawing your own curves. This feature gives you complete control over each movement of every property in the projects you create with Flash.
Where to go from here
For more information about the new and improved way of creating and editing motion tweens using the Timeline and Motion Editor, visit the Animation Learning Guide for Flash CS4 Professional. Also read Motion migration guide for Flash CS4 Professional if you have used animation in earlier versions of Flash and want to learn how to migrate your skill set.
Note: This article appeared originally in the Edge newsletter.
This work is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License
More Like This
- Creating a simple animation in Flash
- Building Preloaders and Progress Bars in Macromedia Flash
- Augmented reality with animated avatars using the 3D drawing API
- Automating tasks in Flash Professional CS5
- Using the Adobe Flash Sprite Sheet Generator
- Automating tasks in Flash Professional CS6
- Lip-syncing automatically with SmartMouth in Flash Professional
- Creating an accessible animated presentation in Flash
- Creating a simple document in Flash CS4 Professional
- Creating graphic effects using the new Deco scripts in Flash Professional CS5


text:
Polyfoam has a well established injection moulding plant with over 40 years of in-house experience. We can arrange to build tooling on your behalf, including tool trials and supply of off-tool samples. Polyfoam can also supply injection moulded plastic components in machines from 40 tonnes to over 500 tonnes on a continuous production basis. Polyfoam retained all of the Unity Plastics tooling and are able to supply components from this tooling. We presently mould plastic components for the following industries:
- Automotive
- Packaging
- Medical
- Building
- Consumer industries
Materials currently processed in our Dandenong facility include, but are not limited to:
- Polypropylene
- Nylon
- High Density Polyethylene (HDPE)
- Low Density Polyethylene (LDPE)
- Polycarbonate
- Acetal Resin
For further information on these, or other customised applications, please contact Polyfoam.


text:
Browsing Department of Economics (ECON) by Title
Previous Page
Now showing items 151-170 of 276Next Page
Labour Market, Health Care and Prescription DrugsHøjbjerg Jacobsen, Rasmus (Frederiksberg, 2011)[More information][Less information]
Abstract: This paper uses a register dataset for the entire Danish population to examine the effect of early motherhood on labour market measures, health care measures and family measures for the mothers and their offspring. The dataset is divided into three groups according to the age of the woman at the time of her first child delivery. Using standard cross-sectional econometric techniques the results show that very young mothers (aged 16-21) have significantly lower employment rates, higher propensity to receive welfare benefits and a lower wage income. Children of very young mothers have a higher family replacement rate, more services received from General Practitioners and a higher propensity to receive ADHD-medications. The majority of the effects reported are also significantly greater for mothers who were aged 22-25 at the birth of their first child compared to older mothers. URI: http://hdl.handle.net/10398/8377
Files in this item: 1Rasmus_Hoejbjerg_Jacobsen_wp_2011.pdf (92.36Kb)
problems, policies and prospectsAndersen, Torben M.; Hougaard Jensen, Svend E.; Risager, Ole (København, 1998)[More information][Less information]
Abstract: Over the last 25 years the Danish economy has had difficulties in growing as fast as other EU countries and the United States. While the average growth difference is small, it signals that if this trend persists into the next century, Denmark will not be able to maintain its high position in the world income hierarchy. Moreover, during these years, the number of individuals living on transfer incomes have increased dramatically. Although we interpret both tendencies as signals of structural weaknesses, we are also aware that these developments may reflect that other goals in economic policy have been pursued, such as protecting the environment and/or achieving certain redistributive objectives. This paper analyzes this and other broad policy issues of importance for Denmark. URI: http://hdl.handle.net/10398/7612
Files in this item: 11998_18.pdf (175.5Kb)
en detaljeret oversigtMøllgaard, H. Peter (København, 1999)[More information][Less information]
URI: http://hdl.handle.net/10398/7520
Files in this item: 11998_14.pdf (105.4Kb)
Møllgaard, Peter; Overgaard, Per Baltzer (København, 2001)[More information][Less information]
URI: http://hdl.handle.net/10398/7567
Files in this item: 1wpec062001.pdf (1.207Mb)
A Tax Optimality IndexRaimondos-Møller, Pascalis; Woodland, Alan D. (København, 2004)[More information][Less information]
Abstract: This paper introduces an index of tax optimality that measures the distance of some current tax structure from the optimal tax structure in the presence of public goods. In doing so, we derive a [0, 1] number that reveals immediately how far the current tax configuration is from the optimal one and, thereby, the degree of efficiency of a tax system. We call this number the Tax Optimality Index. We show how the basic method can be altered in order to derive a revenue equivalent uniform tax, which measures the size of the public sector. A numerical example is used to illustrate the method developed. JEL Code: H21, H41. Keywords: Tax optimality index, excess burden, distance function. Authors Affiliations: Raimondos-Møller: Copenhagen Business School, CEPR, CESifo, and EPRU. Woodland: University of Sydney. URI: http://hdl.handle.net/10398/7534
Files in this item: 1wpec052004.pdf (385.9Kb)
Marker-Larsen, Svend (København, 2005)[More information][Less information]
URI: http://hdl.handle.net/10398/7499
Files in this item: 1wp5-2005.pdf (498.2Kb)
Schneider, Cedric (København, 2008)[More information][Less information]
Abstract: This paper analyzes the effects of mixed public-private R&D incentives and empirically tests whether patents that were publicly sponsored are more important than non-subsidized ones. Blending patents and public subsidies will allow the funding agency to subsidize inventions that would otherwise not elicit investment because the private incentive will not fully cover the cost of the invention. Thus, the policy maker will only subsidize inventions that have a high social value. The empirical analysis shows that subsidized inventions result in more important patents, as measured by the number of forward citations. URI: http://hdl.handle.net/10398/7662
Files in this item: 1wp6-2008.pdf (150.8Kb)
The Role of Fundamentals Using a Regime-Switching ApproachNielsen, Steen; Overgaard Olesen, Jan (København, 2000)[More information][Less information]
URI: http://hdl.handle.net/10398/7556
Files in this item: 1wpec122000.pdf (210.4Kb)
The Choice of Educational TypeAlstadsæter, Annette; Kolm, Ann-Sofie; Larsen, Birthe (København, 2005)[More information][Less information]
Abstract: This paper examines the effect of taxes on the individuals' choices of educational direction, and thus on the economy.s skill composition. A proportional labour tax induces too many workers with high innate ability to choose an educational type associated with high consumption value and low effort. This increases the skill mismatch and aggregate unemployment in the economy. The government can correct for this distortion by use of differentiated tuition fees or tax rates. JEL codes: J64, J68, H21, H24 Keywords: Unemployment, matching, education, optimal taxation, tuition fees URI: http://hdl.handle.net/10398/7562
Files in this item: 1wp23-2005.pdf (207.8Kb)
Kolm, Ann-Sofie; Larsen, Birthe (København, 2001)[More information][Less information]
URI: http://hdl.handle.net/10398/7525
Files in this item: 1wpec012001.pdf (805.8Kb)
Multidimensional Welfare Comparisons of EU Member States Before, During, and After the Financial CrisisA Dominance ApproachHussain, M. Azhar; Siersbæk, Nikolaj; Østerdal, Lars Peter (Frederiksberg, 2018)[More information][Less information]
Abstract: How did the financial crisis affect population welfare in EU member states in key dimensions such as income, health, and education? We seek to answer this question by way of welfare comparisons between countries and within countries over time, using EU-SILC data. Our study is novel in using a multidimensional first order dominance comparison approach on the basis of multi-level ordinal data. We find that the countries most often dominated are southern and eastern European member states, and the dominant countries are mostly northern and western European member states. However, for most country comparisons, there is no dominance relationship. Moreover, only a few member states have experienced a temporal dominance improvement in welfare, while no member states have experienced a temporal dominance deterioration during the financial crisis. URI: http://hdl.handle.net/10398/9657
Files in this item: 1multidimensional.pdf (589.5Kb)
Lund, Lars (København, 2003)[More information][Less information]
URI: http://hdl.handle.net/10398/7632
Files in this item: 1wpec042003.pdf (909.6Kb)
Huizinga, Harry; Nielsen, Søren Bo (København, 2004)[More information][Less information]
Abstract: Internationalization offers enhanced opportunities for individuals to place savings abroad and evade domestic saving taxation. This paper asks whether the concomi- tant loss of saving taxation necessarily is harmful. To this end we construct a model of many symmetric countries in which public goods are financed by taxes on saving and investment. There is international cross-ownership of firms, and countries are assumed to be unable to tax away pure profits. Countries then face an incentive to impose a rather high investment tax also borne by foreigners. In this setting, the loss of the saving tax instrument on account of international tax evasion may prevent the overall saving-investment tax wedge from becoming too high, and hence may be beneficial for moderate preferences for public goods. A world with 'high- spending' governments, in contrast, is made worse off by the loss of saving taxes, and hence stands to gain from international cooperation to restore saving taxation. JEL-Classifcation: H87, H21 Keywords: Capital income taxation, cross-ownership, coordination URI: http://hdl.handle.net/10398/7535
Files in this item: 1wpec152004.pdf (172.2Kb)
Møllgaard, Peter (København, 2002)[More information][Less information]
URI: http://hdl.handle.net/10398/7646
Files in this item: 1wpec022002.pdf (51.7Kb)
Bennett, Patrick; La Cour, Lisbeth; Larsen, Birthe; Waisman, Gisela (Frederiksberg, 2015)[More information][Less information]
Abstract: This paper explores potential explanations behind the educational gap between young natives and immigrants using two measures, negative attitudes towards immigrants and networking, which may influence natives and immigrants differently. The paper considers, both theoretically and empirically, the impact of negative attitudes and networking taking into account that these parameters may influence high and uneducated workers as well as immigrants and natives differently, creating different incentives to acquire education for the two ethnic groups. Using rich Danish administrative data, this paper finds evidence that greater negative attitudes increase incentives for males to acquire education and that networking also increases immigrant education. URI: http://hdl.handle.net/10398/9153
Files in this item: 1wp 1-2015 pdf la cour larsen.pdf (2.047Mb)
Urban, Dieter M. (København, 1998)[More information][Less information]
URI: http://hdl.handle.net/10398/7528
Files in this item: 11998_16.pdf (294.6Kb)
Hvidt, Morten; Nielsen, Søren Bo (København, 2000)[More information][Less information]
URI: http://hdl.handle.net/10398/7644
Files in this item: 1wpec172000.pdf (204.1Kb)
Andersen, Steffen; Harrison, Glenn W.; Hole, Arne Risa; Rutström, E. Elisabet (Frederiksberg, 2010)[More information][Less information]
Abstract: We develop an extension of the familiar linear mixed logit model to allow for the direct estimation of parametric non-linear functions defined over structural parameters. A classic application is the estimation of coefficients of utility functions to characterize risk attitudes. There are several unexpected benefits of this extension, apart from the ability to directly estimate structural parameters of theoretical interest. URI: http://hdl.handle.net/10398/8171
Files in this item: 1wp4-2010.pdf (174.4Kb)
Andersen, Steffen; Harrison, Glenn W.; Hole, Arne Risa; Rutström, E. Elisabet (, 2009)[More information][Less information]
Abstract: Experimental data exhibit considerable individual heterogeneity. We review the econometric methods employed to characterize that heterogeneity. We pay particular attention to the trade-off between collecting and allowing for observable characteristics, such as the familiar demographics, and the use of statistical methods to allow for unobserved individual heterogeneity. We demonstrate that these tools are complementary. URI: http://hdl.handle.net/10398/7802
Files in this item: 1wp2009-6.pdf (420.1Kb)
Raimondos-Møller, Pascalis; Woodland, Alan D. (København, 2004)[More information][Less information]
Abstract: This paper examines the welfare implications of non-discriminatory tariff reforms by a subset of countries, which we term a non-preferential trading club. We show that there exist coordinated tariff reforms, accompanied by appropriate income transfers between the member countries, that unambiguously increase the welfare of these countries while leaving the welfare of non-members unaltered. In terms of economic policy implications, our results show that there exist regional, MFN-consistent arrangements that lead to Pareto improvements in world welfare. JEL code: F15. Keywords: Trading clubs, non-preferential tariff reform, Kemp-Wan-Ohyama proposition. URI: http://hdl.handle.net/10398/7540
Files in this item: 1wpec062004.pdf (262.2Kb)
Previous Page
Now showing items 151-170 of 276Next Page


text: Our Many Europes Our Many Europes. Europe's Critical '90s and the Constituent MuseumOur Many Europes is a programme organised by the European museum confederation L'Internationale and co-financed by the European Union's Creative Europe programme. The members of L'Internationale and its partners Valand Academy (University of Gothenburg, Sweden) and the National College of Art and Design, Dublin (NCAD, Ireland) will present more than 40 public activities (conferences, exhibitions, workshops) in the framework of this project.


text:
I'm currently reading Head First Design Patterns, and am finding it very useful and educational. One problem, though – it's all in Java. So I thought that as part of the exercises, I'd translate the code to Delphi. And also as part of my learning process, I thought it would be a good idea to post an article about each of the patterns. I also encourage you to buy the book and read it for yourself.
Let me be clear – I'm not doing any more than reproducing the demos in the book. I'm very aware that there are better ways to implement the patterns than are shown here. The idea is to learn the pattern, not optimize the code.
I'm currently reading Head First Design Patterns, and am finding it very useful and educational. One problem, though – it's all in Java. So I thought that as part of the exercises, I'd translate the code to Delphi. And also as part of my learning process, I thought it would be a good idea to post an article about each of the patterns. I also encourage you to buy the book and read it for yourself.
Let me be clear – I'm not doing any more than reproducing the demos in the book. I'm very aware that there are better ways to implement the patterns than are shown here. The idea is to learn the pattern, not optimize the code.
Continuing on through HFDP, the next pattern we'll cover is the Decorator Pattern.
One of the themes of the book is to make your code as flexible as possible at runtime, and to design your code to prefer runtime flexibility over compile time flexibility. Anytime you determine something at compile-time, you lock that feature in to your code. It can't be changed at runtime.
Inheritance is a pillar of OOP, but it is a compile-time construct. Inheritance is powerful, but inflexible at runtime. You have the classes you have, and they can't be altered or changed once you set them in the stone that is compiled code. If you are trying to come up with differing combinations to decorate each class, you can end up having a huge number of descendent classes which can become difficult to manage and maintain. Changes to one of the features means any number of descendants might need to change as well.
The decorator pattern is a way of circumventing these limitations, and providing the power of inheritance while at the same time providing run-time flexibility. It actually uses some simple inheritance to "wrap up" a given class and provide additional functionality without having to change the original class.
Here is the formal definition from Wikipedia: The Decorator Pattern attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to sub-classing for extending functionality. You can read more about the pattern on Wikipedia.
Here is the formal definition from Wikipedia: The Decorator Pattern attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to sub-classing for extending functionality. You can read more about the pattern on Wikipedia.
It's actually pretty straight-forward. Here's what you do:
Okay, let's take a look at that in code. Here is the base class, TBeverage:
TBeverage = class
FDescription: string;
function GetDescription: string; virtual;
procedure SetDescription(const Value: string);
function Cost: Double; virtual; abstract;
property Description: string read GetDescription write SetDescription;
The base class is abstract. It has two properties, with the Cost property being read-only and having an abstract, virtual getter.
TBeverage is the base class for the beginning of the wrapping process. We create descendants that will form the base class described above. These classes override the Cost method, providing their own prices. They will be the starting point for decorating. In our case, we'll create specific base coffee types that can be wrapped:
TEspresso = class(TBeverage)
constructor Create;
function Cost: Double; override;
THouseBlend = class(TBeverage)
constructor Create;
function Cost: Double; override;
TDarkRoast = class(TBeverage)
constructor Create;
function Cost: Double; override;
TDecaf = class(TBeverage)
constructor Create;
function Cost: Double; override;
The interesting part comes in the base decorator class:
TBeverageDecorator = class(TBeverage)
FBeverage: TBeverage;
constructor Create(aBeverage: TBeverage);
destructor Destroy; override;
TBeverageDecorator does three things. One, it descends from TBeverage. Two, it gets another instance of TBeverage from its constructor in order to "wrap" itself around the starting base class. And three, the destructor ensures that the internally stored instance gets freed properly when that time comes.
Since TBeverageDecorator is itself a TBeverage, you can continue wrapping the previous result in a new one, decorating the decorator as it were. In addition, it will have the exact same interface as the base beverage class, so it can act like a beverage because, well, it is one.
As for classes that do the decorating, they will descend from TBeverageDecorator:
TMocha = class(TBeverageDecorator)
function GetDescription: string; override;
function Cost: Double; override;
TSoy = class(TBeverageDecorator)
function GetDescription: string; override;
function Cost: Double; override;
TWhip = class(TBeverageDecorator)
function GetDescription: string; override;
function Cost: Double; override;
Each of these classes does two things.
First, they override the getter for the Description property. They do it in an interesting way. Since they are decorating the base Beverage, they assume that they are "additive", that is that they will be adding on to the base description. The TMocha.GetDescription method looks like this:
function TMocha.GetDescription: string;
Result := FBeverage.GetDescription + ', Mocha';
This method grabs the description from the class that it is wrapping and adds on a comma and its own description.
Second, the Cost method is overridden to add the cost to the price of the class that it is decorating.
function TMocha.Cost: Double;
Result := 0.20 + FBeverage.Cost;
So, now we have a bunch of types of coffee – the base classes --and a bunch of flavors to wrap around those classes and themselves. Let's put it all together:
First, we'll create a routine to write out the coffee type to the console:
procedure OutputBeverage(aBeverage: TBeverage);
WriteLn('A ', aBeverage.Description, ' costs ', '$', Format('%2f', [aBeverage.Cost]));
Then, we'll create an Espresso and wrap it with Double Mocha and Whip:
procedure OrderCoffee;
Beverage: TBeverage;
Beverage := TEspresso.Create;
Beverage := TMocha.Create(Beverage);
Beverage := TMocha.Create(Beverage);
Beverage := TWhip.Create(Beverage);
This will build the description and calculate the correct price, and result in:
Another way that you can create a coffee is by simply nesting each decorator in the constructor of the previous one. This method actually provides a coding representation of how each decorator wraps up the previous one:
// Alternate way to call the same thing as above....
Beverage3 := TWhip.Create(TMocha.Create(TMocha.Create(TDarkRoast.Create)));
The complete implementation of our little coffee shop application can be found on BitBucket. That code should be a faithful representation of the final project in the book. And I have mentioned that I strongly recommend that you buy the book, right?
So, to summarize:
There are some problems here – you can end up with a lot of little classes to manage; that might bother some people. Use of decorators can lead to complex code and implementations – use them with care.
However, the basic idea is to simplify and add flexibility to your code over a complex inheritance model. In addition, it makes it easier to build a single instance at run-time of complicated combinations of features or items.
Next up: The Factory Pattern
I'm currently reading Head First Design Patterns, and am finding it very useful and educational. One problem, though – it's all in Java. So I thought that as part of the exercises, I'd translate the code to Delphi. And also as part of my learning process, I thought it would be a good idea to post an article about each of the patterns. I also encourage you to buy the book and read it for yourself.
The first real pattern that the book shows is the Observer Pattern. You should use the observer pattern when you have one object that notifies other objects when events occur. Or more succinctly, use it when you have an object that needs to notify other objects about stuff that happens.
HFDP uses the example of a simple weather station that gathers data about the weather. Each time the weather station takes readings, it needs to update the views of that weather. The weather station reports on Temperature, Humidity, and Pressure. There are three views that the application provides – current conditions, statistics about the weather, a simple forecast.
The idea here is that the weather station is the subject – it is the object being observed and doing the notifying. The different displays for the information are the observers – they watch what happens on the weather station and update themselves based on the notifications that they receive from the weather station. Another way to look at it is that the weather station is a publisher of information, and the displays are subscribers.
The formal definition given for the Observer Pattern goes like this: The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically.
The formal definition given for the Observer Pattern goes like this: The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically.
But when it comes time to implement this, the temptation is to simply embed the displays inside of a method of the weather station. You might create classes for each view, instantiate them in the weather stations constructor, and then simply update the views in a method called MeasurementsChanged.
But of course if you do this, you are breaking some of the base design rules. First, you'd be coding against an implementation instead of against an interface. Second, you've made it really hard to add a new data display should that become necessary. Displays are hard-coded into the weather station and can't be added or removed at runtime. If we do want to add more displays, we'd need to modify the weather station itself. Or, put more succinctly, the weather station and its displays are tightly coupled to each other. And if you know one thing about me, I abhor tight coupling. And you should too.
In any event, there is a better way – the Observer Pattern. As noted above, observer pattern consists of a Subject that is monitored by Observers. We'll implement a very simple version of the observer pattern. The first thing we will do of course, is declare two interfaces:
IObserver = interface
procedure Update(aTemperature: integer; aHumidity: integer; aPressure: Double);
ISubject = interface
procedure RegisterObserver(aObserver: IObserver);
procedure RemoveObserver(aObserver: IObserver);
procedure NotifyObservers;
The first interface is IObserver, which the observing classes will implement. In it they'll be updated with all the weather information that the weather station has for us. The second is ISubject, which will be implemented by the weather station. It takes three methods, two for handling the connecting and disconnecting of IObservers, and the third for doing the actual notification to the observers.
The first implementation we'll look at is the Weather Station. Here is its implementation declaration.
TWeatherData = class(TInterfacedObject, ISubject)
FTemperature: integer;
FHumidity: integer;
FPressure: double;
FObserverList: TList<IObserver>;
function GetTemperature: integer;
function GetHumidity: integer;
function GetPressure: double;
constructor Create;
destructor Destroy; override;
procedure SetWeatherInformation(aTemperature: integer; aHumidity: integer; aPressure: double);
procedure RegisterObserver(aObserver: IObserver);
procedure RemoveObserver(aObserver: IObserver);
procedure NotifyObservers;
procedure MeasurementsChanged;
property Temperature: integer read GetTemperature;
property Humidity: integer read GetHumidity;
property Pressure: double read GetPressure;
The plumbing for managing the weather implementation is all what you'd expect. The interesting part, of course, is the implementation of ISubject. Internally, it uses a TList<IObserver> to manage all the observers that get registered with it. The RegisterObserver and RemoveObserver methods simply insert and remove, respectively, instances of classes that implement the IObserver interface.
The real action occurs in the NotifyObservers method. We'll get to that in a second. First, though, let's take a look at the observers. Since all the displays are very similar, this is a good time to use good old-fashioned inheritance to declare a base class that implements the needed functionality, and then have descendent classes that do the work of providing the specified displays. Here, then, is the interface for TWeatherDataDisplay:
TWeatherDataDisplay = class(TInterfacedObject, IObserver, IDisplay)
FSubject: TWeatherData;
FTemperature: integer;
FHumidity: integer;
FPressure: Double;
constructor Create(aWeatherData: TWeatherData);
destructor Destroy; override;
procedure Update(aTemperature: integer; aHumidity: integer; aPressure: Double); virtual;
procedure Display; virtual; abstract;
TWeatherDataDisplay has fields to keep track of the current weather information. It's descendants can do with it as they please. It also implements the IDisplay interface so that it can report out what it has to say. The Update method will allow the Subject – in this case the weather station – to update the displays. Update is a virtual method, by the way, so that descendants can do different things with the incoming information.
Okay, so let's look under the hood. The weather station can accept and remove IObserver implementers at runtime. implements the NotifyObservers method as part of the ISubject interface. It gets called whenever the weather information changes. It is implemented as follows:
procedure TWeatherData.NotifyObservers;
Observer: IObserver;
for Observer in FObserverList do
Observer.Update(Temperature, Humidity, Pressure);
This is pretty simple – it merely enumerates over each item in the observer list and calls the Update method, passing along the new weather data. The base class stores the information, and its descendants process it.
The real "work" gets done when the weather station updates the temperature data and calls NotifyObservers:
procedure TWeatherData.SetWeatherInformation(aTemperature, aHumidity: integer; aPressure: double);
FTemperature := aTemperature;
FHumidity := aHumidity;
FPressure := aPressure;
The entire implementation of our little weather station can be found as part of my demo code on BitBucket.org.
The entire implementation of our little weather station can be found as part of my demo code on BitBucket.org.
So all of this comes together in a method to create a weather station and add observers:
procedure DoWeatherStation;
WeatherStation: TWeatherStation;
CurrentDisplay: IDisplay;
ForecastDisplay: IDisplay;
StatsDisplay: IDisplay;
WeatherStation := TWeatherStation.Create;
CurrentDisplay := TCurrentConditionsDisplay.Create(WeatherData);
ForecastDisplay := TForecastDisplay.Create(WeatherData);
StatsDisplay := TStatisticsDisplay.Create(WeatherData);;
WeatherStation.SetWeatherInformation(70, 55, 28.90);
WeatherStation.SetWeatherInformation(68, 59, 28.96);
WeatherStation.SetWeatherInformation(35, 66, 27.40);
WeatherStation.SetWeatherInformation(55, 55, 27.40);
Here are some interesting things to note:
So that should be a quick rundown on how the observer pattern works. The obvious weakness here is that our IObserver interface is very specific to weather data. You can create your own interface for your specific implementation. The pattern remains the same no matter how the IObserver interface is designed. This is obviously a good place for generics to enter the picture, and in fact, the Delphi Spring framework implements a generic IObservable<T> interface and implementing class.
So in summation, the Observer pattern ensures that publishing classes (subjects) can communicate updates to their subscribing (observer) classes with very loose and flexible coupling. Observers can be updated and removed at runtime. Adding observers requires no change to subjects. Subjects don't know much at all about what the observers are up to. It's all very easy and elegant and loosely coupled – just like you want it.
Next up – the Decorator Pattern.
One of those fun little issues in our business is trying to figure out the difference between iterating and enumerating. This StackOverflow answer does a pretty good job of explaining it. Iterating is doing something – usually a series of steps – over and over again. Enumerating is going over each item in a given collection. A subtle difference, sure. One usually iterates when enumerating.
Okay, so enumerating is going over each item in a collection. IEnumerable can enumerate over the items in a collection as we saw in my last article. But you can enumerate over other things as well. For instance, in Delphi, you can use the for…in statement to enumerate over the characters in a string.
But this makes me wonder: how does something become, well, enumeratable? How do you make something so that you can use with the for…in statement?
Well, it's pretty easy. The rules for Delphi are simple:
So, at this point, a simple demo would be helpful, eh?
You can already enumerate the characters in a string, but it's a simple example, and so the following example implements this easy to understand enumeration on a string:
TForInDemoClassEnumerator = class
FString: string;
FIndex: integer;
function GetCurrent: Char; virtual;
constructor Create(aString: string);
function MoveNext: Boolean;
property Current: Char read GetCurrent;
TForInDemo = class
FTheString: string;
procedure SetTheString(const Value: string);
constructor Create(aString: string);
function GetEnumerator: TForInDemoClassEnumerator;
property TheString: string read FTheString write SetTheString;
This code declares two classes. The first class is the enumerator – the class that does the work of moving over each item, and which will be returned by the call to GetEnumerator. The second is the class that will be enumerated. Notice, too, that TForInDemoClassEnumerator has the read-only property Current with the reader GetCurrent and MoveNext methods. The TForInDemo class has a call to GetEnumerator that returns an instance of TForInDemoClassEnumerator.
First let's look at TForInDemoClassEnumerator. You create it by passing the constructor the item to be enumerated – in this case a string. Hence, the constructor:
constructor Create(aString: string);
Here is the implementation of the MoveNext method:
function TForInDemoClassEnumerator.MoveNext: Boolean;
Result := FIndex < FString.Length;
if Result then
This code does two things. First, it sets the result. The function returns True if the enumerator is able to move to the next item, and False if it has reached the end of the items to be enumerated. In this case, it merely checks to see the index is before the length of the string. If the end has not yet been reached, it just increases the FIndex field. So it's job here is merely to move the index along, and report if the end has been reached.
The actual item itself is returned by the GetCurrent method, which is self-explanatory:
function TForInDemoClassEnumerator.GetCurrent: Char;
Result := FString[FIndex];
And that is it for the enumerator. It's pretty simple. But we'll soon see that you can do some cool things with these enumerators because you have complete control over how they return the data that they are enumerating over.
The next step is to see how the actual class to be enumerated provides its enumerator to the compiler. When the compiler builds the for…in loop construct, it looks at the in part of the construct and thinks "Hey, I need an enumerator here, so I'll call GetEnumerator". If the item in question indeed has a method called GetEnumerator, it calls it, and all is well. If not, the compiler raises an error because the type in the in part of the for…in loop isn't enumeratable.
But of course, our TForInDemo class has such a method, and it is quite simple:
function TForInDemo.GetEnumerator: TForInDemoClassEnumerator;
Result := TForInDemoClassEnumerator.Create(FTheString);
It merely creates and returns an instance of our enumerator, passing it the string value it is storing for the purpose of enumerating. Pretty easy and straight forward, really.
Now that we've created all these classes, you can run the following code:
procedure DoStuff;
ForInDemo: TForInDemo;
C: Char;
ForInDemo := TForInDemo.Create('HelloWorld');;
for C in ForInDemo do
Write(C, ',');
Now the above discussion talks a lot about specific methods that must be included as part of an enumerator, and as part of a class that wants to be enumerated. And of course, that should immediately make you think "Interfaces!". And sure enough, there are some nice interfaces that fall out of this. (You knew I'd work interfaces into things here eventually, didn't you. Yes, you did.)
Consider this interface:
IEnumerator<T> = interface
function GetCurrent: T;
function MoveNext: Boolean;
property Current: T read GetCurrent;
That should look awfully familiar. It's the exact two methods and one property needed to implement an enumerator – hence the name.
I've declared this IEnumerator<T> interface myself, but the Delphi RTL includes a similar one in the System.pas unit. And at its base, IEnumerable<T> is all about implementing the GetEnumerator method.
I've declared this IEnumerator<T> interface myself, but the Delphi RTL includes a similar one in the System.pas unit. And at its base, IEnumerable<T> is all about implementing the GetEnumerator method.
It leverages generics because the type of what is being enumerated doesn't matter as far as the interface is concerned. And remember when I said that a call to GetEnumerator could return an interface? Well it can, and the compiler will happily use an IEnumerator<T> to implement the for…in loop.
Thus, your enumerators can implement this interface and your calls to GetEnumerator can return this interface, and you can add flexibility to how they are implemented. Here's an example:
TStringEnumerator = class(TInterfacedObject, IEnumerator<Char>)
FIndex: integer;
FString: string;
function GetCurrent: Char;
constructor Create(aString: string);
function MoveNext: Boolean;
property Current: Char read GetCurrent;
TInterfaceEnumeratorDemo = class
FTheString: string;
procedure SetTheString(const Value: string);
constructor Create(aString: string);
function GetEnumerator: IEnumerator<Char>;
property TheString: string read FTheString write SetTheString;
Notice that the call to GetEnumerator returns an IEnumerator<Char> which is actually the individual type being iterated. In this case, the generic type needs to be the same type as the variable being returned in the for part of the for…in loop.
This enables you to do the following:
procedure DoInterfaceStuff;
InterfacedEnumerator: TInterfaceEnumeratorDemo;
c: Char;
InterfacedEnumerator := TInterfaceEnumeratorDemo.Create('GoodbyeWorld');
for c in InterfacedEnumerator do
Write(C, ',');
The implementation of an enumerator is, as I mentioned, really simple. But what if you wanted to get a little creative in the GetCurrent method? After all, at that point you have complete control over what the enumerator returns. In our simple case with characters and strings, what if we decided to, say, always return the upper case version of the character? Or if we were iterating over integers, return the squares of the numbers in the collection? That would be super easy, right? Well, yes, it would.
Consider this code:
TForInDemoClassUpperCaseEnumerator = class(TForInDemoClassEnumerator)
function GetCurrent: Char; override;
function TForInDemoClassUpperCaseEnumerator.GetCurrent: Char;
Result := UpCase(inherited GetCurrent);
This class descends from TForInDemoClassEnumerator and overrides the existing enumerator for our demo class and returns the upper case of the character in question.
If we wanted, we could return this class from our GetEnumerator call, but that would be sort of playing a trick on the user of our code. How about if we provide two different enumerators, and then make each available for enumeration in a for…in loop. Surely that is possible, right? Of course it is.
First, we'll look at the end result and then work our way backwards to see how it was implemented, because you have to play a little trick to expose more than one enumerator for a class:
procedure DoMoreStuff;
C: Char;
ForInExtraDemo: TForInDemoExtraIterators;
ForInExtraDemo := TForInDemoExtraIterators.Create('Greetings');
for C in ForInExtraDemo.AsUpperCase do
Write(C, ',');
This little routine will display the string "Greetings" as "G,R,E,E,T,I,N,G,S" in the console. But note in the for…in loop that the actual class is not passed to the in clause, but a method that returns a "proxy" class that has the desired enumerator attached to it instead. This is implemented as follows:
TUpperCaseEnumeratorProxy = class
FOwner: TForInDemo;
constructor Create(aOwner: TForInDemo);
function GetEnumerator: TForInDemoClassUpperCaseEnumerator;
constructor TUpperCaseEnumeratorProxy.Create(aOwner: TForInDemo);
inherited Create;
FOwner := aOwner
function TUpperCaseEnumeratorProxy.GetEnumerator: TForInDemoClassUpperCaseEnumerator;
Result := TForInDemoClassUpperCaseEnumerator.Create(FOwner.TheString);
This is just another class that can be enumerated – it has a call to GetEnumerator – and thus be returned by a method call on our "real" enumerating class. It returns an instance of an enumerator called TForInDemoClassUpperCaseEnumerator which we looked at above. So, if you want to iterate over the upper case version of the strings, you call it as we did in the DoMoreStuff method above. The trick here is that instead of iterating over the class itself, you iterate over the proxy class using ForInExtraDemo.AsUpperCase. It's a neat little trick, eh?
Thus, the enumerating class becomes:
TForInDemoExtraIterators = class(TForInDemo)
FUpper: TUpperCaseEnumeratorProxy;
constructor Create(aString: string);
property AsUpperCase: TUpperCaseEnumeratorProxy read FUpper;
constructor TForInDemoExtraIterators.Create(aString: string);
inherited Create(aString);
FUpper := TUpperCaseEnumeratorProxy.Create(Self);
So, that should give you a little insight into what happens with for…in loops and how you can create classes that participate automatically. I'm working towards never using the old for I := 0 to Count –1 do; construct, and making my classes enumeratable.
The code for this article with further examples can be found with my demo code on BitBucket.
I rave about the Delphi Spring Framework. But I think my attention to the Dependency Injection Framework – which is only part of it -- has made you guys think that the two are synonymous. Not true – Spring4D is more than just a Dependency Injection container. In fact, there is a wealth of other stuff to be found in Spring4D.
Inspired by this StackOverflow question and a thread in the newsgroups, I thought that I'd write an article about a very powerful but not so well known (apparently) feature of Spring4D – IEnumerable<T> and the accompanying container interfaces and classes.
So the StackOverflow question basically asks this: How do I find out the maximum value of an integer in TList<integer>?
Well, the first thing you might do is use a for loop to check each item, and save each one as it gets larger. Or if you were really tricky, you'd use a for…in statement to find it. That's the "straight-up" way to do it.
But that isn't the real answer to the StackOverflow question. The real answer is this:
program ListEnumerableDemo;
{$R *.res}
, Spring.Collections;
List: IList<Integer>;
Enumerable: IEnumerable<integer>;
List := TCollections.CreateList<integer>;
Enumerable := List;
on E: Exception do
Writeln(E.ClassName, ': ', E.Message);
Now that looks quite a bit different than the code you were thinking of, I'll bet. There doesn't even appear to be any looping going on at all. There is in the background, but it's all been abstracted away for you. You want the maximum value to be found in the list? Just ask for it. Cool.
The key part above, of course, is the use of two things. First, the IList<T> – an interface to a generic list – and secondly, the IEnumerable<T>. Both of these types are provided by the Delphi Spring Framework. Both are defined in the Spring.Collections.pas unit. That unit contains a complete group of collection interfaces – IList<T>, IStack<T> ICollection<T>, etc. – as well as the definition of IEnumerable<T>.
I'd recommend that you consider using Spring.Collections.pas instead of the Generics.Collections.pas unit which comes with Delphi. First, it exposes all of the collection types as interfaces, and you should know by now that you should be coding against interfaces and not implementations. Secondly, each of the types supports the IEnumerable<T> interface, meaning you have the power of this great interface on all of your collections.
I'd recommend that you consider using Spring.Collections.pas instead of the Generics.Collections.pas unit which comes with Delphi. First, it exposes all of the collection types as interfaces, and you should know by now that you should be coding against interfaces and not implementations. Secondly, each of the types supports the IEnumerable<T> interface, meaning you have the power of this great interface on all of your collections.
We'll tackle those two things in order.
The Spring.Collections.pas unit is all you need in your uses clause to avail yourself of all that the Spring collections library provides. The unit includes the following interfaces along with a class to provide easy access to implementations of these interfaces:
All of these types should be familiar to you – if not, you can certainly read up on them via Google. The important part is that they are all generic (though there are non-generic types with store TValue as well) and they all implement IEnumerable<T>.
The unit also provides a class called TCollections which has nothing but class methods that return instances of the types listed above. These methods act as proxies for the constructors of the implementing types. You can create your own instances if you like, but for the most part, TCollections will do the job of getting an implementation of whatever container interface you want. For instance, if you want to get a hold of a dictionary, you can do the following:
The example above uses TCollections.CreateList<integer> to get an implementation of the IList<T> interface.
The implementations are all in units named Spring.Collections.Stack.pas and the like, but the Spring.Collections.pas unit exposes almost everything you need, and so as a rule, you should only need it in your uses clauses to take advantage of these powerful containers.
Those of you who also use .Net are familiar with IEnumerable already, but perhaps you didn't know that the same power was available to you in your Delphi code. For those of you not familiar, you are in for a treat.
The IEnumerable<T> interface is implemented by all of the classes discussed in the previous section, and so any of them can be accessed as an IEnumerable<T>.
Here is the declaration of IEnumerable<T>:
IEnumerable<T> = interface(IEnumerable)
function GetEnumerator: IEnumerator<T>;
function AsObject: TObject;
function TryGetFirst(out value: T): Boolean;
function TryGetLast(out value: T): Boolean;
function First: T; overload;
function First(const predicate: TPredicate<T>): T; overload;
function FirstOrDefault: T; overload;
function FirstOrDefault(const defaultValue: T): T; overload;
function FirstOrDefault(const predicate: TPredicate<T>): T; overload;
function Last: T; overload;
function Last(const predicate: TPredicate<T>): T; overload;
function LastOrDefault: T; overload;
function LastOrDefault(const defaultValue: T): T; overload;
function LastOrDefault(const predicate: TPredicate<T>): T; overload;
function Single: T; overload;
function Single(const predicate: TPredicate<T>): T; overload;
function SingleOrDefault: T; overload;
function SingleOrDefault(const predicate: TPredicate<T>): T; overload;
function ElementAt(index: Integer): T;
function ElementAtOrDefault(index: Integer): T;
function All(const predicate: TPredicate<T>): Boolean;
function Any(const predicate: TPredicate<T>): Boolean;
function Contains(const item: T): Boolean; overload;
function Contains(const item: T; const comparer: IEqualityComparer<T>): Boolean; overload;
function Min: T;
function Max: T;
function Where(const predicate: TPredicate<T>): IEnumerable<T>;
function Skip(count: Integer): IEnumerable<T>;
function SkipWhile(const predicate: TPredicate<T>): IEnumerable<T>; overload;
function SkipWhile(const predicate: TFunc<T, Integer, Boolean>): IEnumerable<T>; overload;
function Take(count: Integer): IEnumerable<T>;
function TakeWhile(const predicate: TPredicate<T>): IEnumerable<T>; overload;
function TakeWhile(const predicate: TFunc<T, Integer, Boolean>): IEnumerable<T>; overload;
function Concat(const collection: IEnumerable<T>): IEnumerable<T>;
function Reversed: IEnumerable<T>;
procedure ForEach(const action: TAction<T>); overload;
procedure ForEach(const action: TActionProc<T>); overload;
procedure ForEach(const action: TActionMethod<T>); overload;
function EqualsTo(const collection: IEnumerable<T>): Boolean; overload;
function EqualsTo(const collection: IEnumerable<T>; const comparer: IEqualityComparer<T>): Boolean; overload;
function ToArray: TArray<T>;
function ToList: IList<T>;
function ToSet: ISet<T>;
function GetCount: Integer;
function GetIsEmpty: Boolean;
property Count: Integer read GetCount;
property IsEmpty: Boolean read GetIsEmpty;
That's a lot of cool stuff, right? Many of the methods here are pretty clear -- it's pretty obvious what the Min and Max methods do. But some of the others are a bit trickier. You can get all of the items. You can get the First and Last items. You can get the first x number of items. You can get the items back out as a List, an Array, or a Set. And most powerfully, you can get any particular group of the items out using a predicate.
What is a predicate? A predicate is an anonymous function (or any function, really, but in our case it is an anonymous function) that takes a single const parameter of the type in question and returns True or False.
TPredicate<T> = reference to function(const value: T): Boolean;
It is used with some of the methods of IEnumerable<T> to answer this simple question: In or out? If the predicate is true, then the individual item is "in", or included. If it is "out", then the predicate will return False. So if you want to get all the items in a list strings that contain the letter 'z', then you can do the following:
function ContainsLetterZ: IEnumerable<string>;
List: IList<string>;
List := TCollections.CreateList<string>;
List.AddRange(['zoo', 'park', 'city', 'town', 'museum', 'jazz festival']);
Result := List.Where(function(const aString: string): Boolean
Result := Pos('z', aString) > 0;
The above uses the Where method to determine items that should be returned as part of a new IEnumerable<string>. The above is saying "return to me an enumerable item where all the strings in the list have 'z' in them."
You can do similar things with the TakeWhile method, which returns items from the start of the list as long as the predicate is True, and stops once the predicate is False. You can determine if a given container has or doesn't have a given element. You can Skip over a given number of elements and take the rest. You can use a predicate to SkipWhile a certain thing is true, and then return the rest once the predicate returns True Basically, once you have a reference to a collection or any IEnumerable<T> instance, you can get out of it pretty much anything you want.
Something to consider: If you have a nicely composed class that includes a private IList<T> which gets exposed through proxy methods, then you might want to expose access to the items via a property of type IEnumerable<T> instead of exposing the actual list itself.
Something to consider: If you have a nicely composed class that includes a private IList<T> which gets exposed through proxy methods, then you might want to expose access to the items via a property of type IEnumerable<T> instead of exposing the actual list itself.
And the real power gets unleashed with the very powerful ForEach methods. Folks have always pined for the lovely ForEach since the days of Borland Pascal's old TCollection object, and now it's back in full force, leveraging the power of anonymous methods. Thus, you can have a collection and do what you please with the items. Here is a simple example of just outputting them to the console window, but you can have your TAction<T> do anything at all that you like for each (sorry) element in the container.
procedure SimpleForEachDemo;
List: IList<integer>;
Action: TAction<integer>;
i: Integer;
Action := procedure(const aInt: integer) begin Writeln(Format('This number is: %d', [aInt])); end;
List := TCollections.CreateList<integer>;
for i := 1 to 10 do
So, basically you have a lot of untapped power there in Spring.Collections.pas, eh? The use of IEnumerable<T> and predicates ought to transform your code and change the way you look for things in lists and collections. If you aren't using these powerful tools yet, I strongly recommend that you add them to your tool chest.
I've written a pretty thorough example application for IEnumerable<T> and put it up on BitBucket. I also have some pretty simple examples showing predicates at work.
Remember, the Delphi Spring Framework is more than a Dependency Injection container. And there's more to it than the container classes as well. I strongly recommend that you start treating Spring4D like part of the Delphi Runtime Library. Heck, I wish Embarcadero would do just that.
Sorry for the confusion -- comments should work now. Thanks to Chris Timmons for pointing out the problem.
Who ever knew that the great .38 Special held the secret to a good leadership viewpoint?
Just hold on loosely But don't let her go If you cling too tightly You're gonna lose control "Hold on Loosely" by .38 Special
Just hold on loosely But don't let her go If you cling too tightly You're gonna lose control
"Hold on Loosely" by .38 Special
That simple lyric holds a valuable viewpoint for leaders. The song, of course, is about a girl. But imagine you are holding a small bird in your hand. If you hold the bird too tightly, you'll crush it. If you hold the bird too loosely, it will escape. But if you hold it just right, not too loosely and not too tightly, then the bird will stay in your hand, and maybe even feel safe. And if you focus on it, it's probably not too hard to figure out just the right amount of pressure to keep the bird in your grasp.
It's the same way with leadership. One of the toughest decisions leaders make is how much control to exert over their people. It's a delicate balance. Both too much and too little can cause difficulties and cause you to lose your team. Finding just the right amount of control is a large challenge.
The tendency of many leaders is to "cling too tightly". They tend to want to have close control over their people. They want to make sure every little detail is taken care of, setting rules, procedures, and processes for every little thing to ensure that things never get out of control. They view their people as merely cogs in machine, and thus give them little autonomy to make decision, innovate, improvise, and otherwise come up with their own solutions. They make every decision, ensuring (in their minds) that things are going perfectly.
There is a word for this – micro-management. No one ever thinks that they are being a micro-manager. In my experience, the more a leader micro-manages, the more he thinks he isn't. Micro-managers tend to think that they are providing leadership because it's needed, because their team can't be trusted, or, sadly, because they think that their team is simply incompetent to do the job. Or perhaps they feel that they have to be involved in order to get the credit.
Whatever the reason, a leader who clings too tightly is being ineffective and usually has a negative effect on her team. People feel the lack of trust, and that's demoralizing. Teams that are given little autonomy soon lose their desire to improve and find better ways to do things. When their leader has all the answers and always knows what is best, why even try?
But holding on too loosely can have a similar effect. If a team feels that their leader can't make decisions or is wishy-washy, then they feel adrift and unsure. No one likes a ship captain who doesn't know where the ship should be going. And a ship that is headed nowhere will surely get there. Not making any decisions is no better than making all the decisions.
The trick or course, is to hold with just the right amount of pressure. Good leaders find that perfect balance between control and chaos. They let their team decide how to accomplish tasks within general guidelines. They encourage improvisation and innovation in a search for better ways of doing things. They know that there are some things that need to be done a certain way, but that there are many things that don't. They trust their team to get things done their own way. They know that if a team member gets credit, it reflects positively on their leadership.
In general, they hold just tightly enough to keep things in control. They let team members make decisions. They recognize that mistakes will be made and that daring to do something different is a feature, not a bug. They make decisions when the team needs a decision, and they delegate decisions as much as possible. They recognize that they have a tendency to "squeeze to tightly" and thus, when in doubt, tend to err on the side of holding too loosely. They understand that autonomy and self-direction are very satisfying, and do everything they can to provide that to their team.
Just as a good veterinarian knows how to hold a bird with the right amount of pressure, a good leader knows the precise amount of control to exert over his team.
Here's another article from my series at CodeFez -- and here's the response that Steve Teixeira wrote to it. The comments on both are a pretty interesting discussion.
Here's another article from my series at CodeFez -- and here's the response that Steve Teixeira wrote to it. The comments on both are a pretty interesting discussion.
I never cease to be amazed at how little the average developer knows about economics. I mean, I don't claim to be an expert, but I have taken a college class or two and read up on the basics. Even just understanding the basics, though, gives one surprising insight into why things happen the way they do in the marketplace.
For instance, we are in the process of hiring a new developer at my company. We figured out what qualifications we were looking for and determined about how much salary we wanted to pay. It quickly become apparent, however, that we weren't offering a high enough salary to attract the caliber of candidates we wanted. So what I did was to go on the newsgroups and start whining about not being able to find any good Delphi programmers. Okay, no, I didn't really do that. What we did, of course, was to increase the salary that we were offering. Simple supply and demand issue: There wasn't enough of a supply of good Delphi programmers at the price we wanted to pay, so the solution is to be willing to pay more – a no-brainer decision, really. Once we did that, we found that we have been able to find plenty of valuable candidates. Simple economics.
One common area that I see developers totally misunderstand is that of Delphi pricing. One thing you learn in Economics 101 is that the vast majority of companies are "price searchers". That is, they are constantly searching for a price that will maximize their profits. (Some companies, mainly producers of commodities, are "price takers". That is, they take whatever price is offered. Farmers are a good example. A corn farmer can only sell his corn at market price. If he asks for more, the market will simply buy corn from another farmer that will take the offered price). Borland is definitely a price searcher. They can set their prices as they please, and will do so to maximize profit. Of course, the market will respond to any particular price by demanding a certain number of units at that price. Price searchers are constantly adjusting prices to maximize the amount of money they make.
Note that they don't set price to maximize revenue, but rather profit. The cost of goods sold is a factor here as is the cost of simply having customers. Sometimes a company will actually price a product in order to limit the number of customers they have in order to maximize profits as sometimes having additional customers causes decreased profits. (That may be a bit counter-intuitive, but think of a product that has high production and support costs.) So for example, sometimes doubling your price can increase profits even though it drastically reduces sales. If doubling the price cuts the number of customers you have in half, but also cuts your production and support costs in half as well, your profit increases. (This is a very simple example, and it is actually hopelessly more complicated than that, but you hopefully get the basic idea).
So Borland, having learned from years of experience and copious sales data, is quite aware of what effect various prices have on sales. No doubt by now they have a pretty good idea what price will maximize their profits and how price changes will effect sales.
Where it gets really interesting is pricing outside of the United States. Europe, of example, is a completely different market than the US. Taxes, the demand curve, and the number of potential customers are all different. Borland clearly believes that they need to – and can – charge more in Europe than in the US. The price difference is not related to the exchange rate between the Euro and the Dollar; it has everything to do with maximizing profits. Clearly Borland believes that a higher price in Europe – again, a completely different market – will mean higher profits. That's why Delphi costs more in Europe. I suppose Europeans could view this as "price gouging", but in reality, it's just the market signaling to Borland that it will bear a higher price than will the American market. Simple economics.
Another economic blunder that developers frequently make is ignoring economies of scale. Borland is a big company that is publicly traded. Many Delphi developers work in small, private companies. Borland has legal obligations, overhead costs, and market demands that most little-shop developers don't even know about, much less take into consideration. Borland's main competition is one of the largest corporations in the world. Borland faces investors who expect a return. Borland has to deal with major entities in the media that can write things that can have profound effects on Borland's business. All of this combines to make running Borland a complex and difficult task that most of us simply don't comprehend.
So I love it when a developer posts in the newsgroups something like this: "Borland should just hire two college students to go through and fix all the Delphi bugs in Quality Central." Well, that sounds great, but is clearly isn't that simple. First, fixing bugs in a big product like Delphi is no small, trivial task. Finding people with the talent and skill to do Delphi bug-fixing isn't easy. And they certainly aren't going to be cheap. The notion that some college interns can do it is quite naïve. The economic blunder comes, though, in thinking that the cost of fixing all those bugs is merely the salary of a couple of developers. First, employees aren't cheap, no matter who you hire. Human capital is by far the most costly – and valuable – part of doing business. Secondly, I don't know what your development process is like, but bug fixing at Borland is more than a guy hacking out some code. Every fix has to be extensively tested for efficacy and correctness, and then the whole product has to be regression tested to ensure that any given fix doesn't actually break something else. Fixes need to be incorporated into shipping product and distributed to existing customers. The documentation needs to be updated. And who know what else needs to be done? The point is this: the costs of things that many people think are small are in fact much larger than the average developer appears to realize.
The economics of running a business like Borland isn't something about which I claim to be an expert. But I do know that I don't know enough to be able to claim to know better than Borland. Something to consider before you fire off a post in the newsgroups that starts out "Borland ought to just...."
The views I express here are entirely my own and not necessarily those of any other rational person or organization. However, I strongly recommend that you agree with pretty much everything I say because, well, I'm right. Most of the time. Except when I'm not, in which case, you shouldn't agree with me.
Powered by BlogEngine.NET 126.96.36.199
Theme by Mooglegiant and modified by Nick Hodges


text:
Blake L. necesitaba un nuevo diseño de logotipo y lanzó un concurso de diseño en 99designs.
Un ganador ha sido elegido entre 112 diseños de 25 diseñadores freelance.
Spanfeller Media Group
We are the Spanfeller Media Group, an online media start-up that has been recently seeded by venture capital to launch a series of lifestyle websites. We are extremely excited to get off the ground, and we pride ourselves on being young/hip, cutting-edge, internet-savvy, but extremely professional. While our sites will specialize in food, the arts, the outdoors, and travel, this logo is for Spanfeller Media Group, which is the media holding company.
While the different websites will have their own target audiences/demographics, the Spanfeller Media Group must be a professional, trusted brand that earns the respect of venture capital firms (when we are raising money and soliciting investors), other media companies (which we may approach for partnerships), and other industry professionals.
Ideally, the logo will be designed with a creative spin/font on "SMG" in larger text with "Spanfeller Media Group" written below in smaller lettering.
Let your creativity run wild, but please keep in mind that the goal of this company is to become the next Time, Inc. or New York Times or Newscorp. While we ultimately hope to maintain a crisp, clean, professional image, we also hope to infuse a smidgeon of fun/life into the design. Let's see what you can do! Thanks for your efforts in advance!
Descubre cómo funciona un concurso de diseño u obtén más información sobre nuestros servicios de diseño de logo.


text:
Message Board
Michael Swanwick Message Board
Talk about the novels, new and used books that Swanwick has written!
Author Swanwick's Book Reviews
Bones Of The Earth
Mr. Swanwick has put a unique twist on time travel and basicly thrown out all of the standard thoughts regarding the subject. As an example he makes it clear in his story that a person can travel both forward and back in time and visit themselves and indeed to exchange information and prevent or cause certain things to happen with out collapsing the timeline. He puts his characters into some intersting situations as well as many of the type one would exp...


text:
by Kendall Smith
If you're looking for a delicious, easy-to-prepare appetizer for your next gathering, this baked spinach artichoke dip is just the thing! Whether you're hosting a group, or attending a potluck, this keto dip is sure to be a total crowd pleaser! Made without mayo and ready in just 30 minutes, it's a healthier option that doesn't require a lot of planning!
by Lori Kemph | Mutt & Chops
An oldie but goodie, and the only cinnamon roll recipe I have ever used. Paying homage to Betty Crocker. These pillowy, rustic, amazingly delicious cinnamon rolls are definitely worthy.
by Caroline
Crunchy and tender all at the same time, topped with a gorgeous runny egg. These Kale, Bacon & Egg Breakfast Tostadas make the perfect late breakfast or lazy brunch. Plus they only take about 15 minutes to come together!
by Jennifer Locklin
Our family's favorite dill pickles! Packed with garlic and fresh dill, these crisp dill pickles will add a boost of flavor to any meal. This Czech recipe has been passed down through our family for generations.
by Terri @ that's some good cookin'
Add a smoky sweet flavor to ribs without having to have a smoker. You rock star, you.
by Fiona Kennedy - FreeFromFavourites
Gluten-free and dairy-free.
by Beth Pierce
Do you know anyone that loves a good frappuccino? My daughter and I just love them. There is nothing better than a creamy frozen iced coffee treat. You can whip up this delectable creamy Caramel Frappuccino up in the morning or as after dinner treat.
by Lindsay @ FunnyLoveBlog
She-crab bisque meets mac and cheese in this epic pairing! This mac and cheese is gooey, spiced with Old Bay, and couldn't be easier to make!
by Christina Main (Sweet Lavender Bake Shoppe)
Really vamp up butter for your next brunch party! Great for biscuits, pancakes, waffles and more!
A rich and indulgent chicken and chorizo paella flavoured with saffron and paprika for warmth. A huge hit for any paella, chorizo or rice lover!
Sweet honey baked salmon combines perfectly with slightly bitter endives, radishes and red lettuce. Combined with a zesty lemon oil dressing. Yum!
by Samantha
The best roasted winter squash recipe that's a little sweet and a little savory, with a healthy dose of spice, a dash of lemon zest, and a drizzle of honey.
by Jennifer Banz
You can make this easy low carb soup recipe in no time at all! Use leftover steak if you have it, or cook up some fresh sirloin. You will not regret it!
by Jen Hodder
Pinto beans from scratch are life changing. A bold but true statement.
Real pinto beans, sautéed onions, garlic, jalapeños, an assortment of spices and diced tomatoes … when finished, whole beans melt in your mouth. Melt! And the flavor, astounding.
Super fresh! Flavorful!
Instant Pot Pinto Beans.
For a healthier you, grab this Oatmeal Raisin Cookie Protein Shake instead of an oatmeal raisin cookie!
View Recipe
Prep: 2 mins Cook: 1 min
Serves: 1 Level: Easy
Prep: 5 mins Cook: 5 mins
Serves: 2 Level: Easy
Prep: 30 mins Cook: 5 mins
Prep: 30 mins Cook: -
Serves: 1 Level: Intermediate
Prep: 5 mins Cook: 10 mins
Prep: 5 mins Cook: -
Prep: 10 mins Cook: 10 mins
Serves: 4 Level: Easy
Prep: 5 mins Cook: 1 min
Prep: 2 mins Cook: 2 mins