Aarrgghh!!

ColdFusion 8 Makes It Easier

May 30, 2007

ColdFusion 8 is now out as a public release candidate, and do I have a lot to say.

First off, I think the ColdFusion team did a great job at adding features across the board that would make ColdFusion a much more competitive product. But I think more interesting is looking at what the ColdFusion team is making easier for you in this release.

ColdFusion has, in my opinion, always been about taking the operations that everyone has to do to build web applications and make them easier. Early versions were focused on making talking to databases easier. ColdFusion MX 6 was about porting the codebase over to Java. You could argue that it was about making ColdFusion easier to work cross platform. That's a stretch, so if you prefer we can say it was a rebuilding release. ColdFusion MX 7 was about making interfacing easier. Between <cfreport> and <cfdocument> ColdFusion gained new ways of output data. Flash Forms was intended to make writing form based interfaces easier. Gateways make ColdFusion easier to interact with in non-traditional, non-browser based ways.

So what does this version of ColdFusion make easier? I've been searching for an answer to that for a few hours now and I think I have a few answers.

First, from the original Scorpio Labs Page:

1. ColdFusion 8 will allow ColdFusion developers to create richer, more engaging web applications
2. ColdFusion 8 will provide powerful new insight into server performance and simplify application troubleshooting
3. ColdFusion 8 will give developers broader platform support and enterprise integration

Here's my translation:

1. ColdFusion 8 makes Web 2.0 Easier
2. ColdFusion 8 makes Administration Easier
3. ColdFusion 8 makes selling ColdFusion to the Enterprise easier

ColdFusion 8 makes Web 2.0 easier

Cheesy, unliked, overused and unfortunately for me, necessary, the Web 2.0 moniker is unfortunately here to stay. It's about many things. But I've always liked it, because I've always looked at it not from a technology perspective, (It's Ajax, or Flex) but from an authority focus. Web 2.0 is about user content, not "authority" based content. It's about users choosing how to consume their applications, not site owners dictating how to consume it.

One could make the argument, that there are only two types of typical, Web 2.0 user data that ColdFusion has to date, not dealt well with. They are Video and Images. Video is still shaking out, and still isn't addressed by ColdFusion. (Adobe as a whole has direction on this.) But at least on the image side of things, ColdFusion 8 makes it easier to handle with <cfimage> and the suite of image functions.

It has always been easy to do Flex development against ColdFusion, but now <cfajaxproxy> and the JSON functions are making it easier to do Ajax development against ColdFusion. This further separates the choice of ColdFusion from the front end used to access it. This is a good thing, it expands a bit on what they did with 7, but also allows "ColdFusion and Ajax" to be said a lot together in press releases and technical news articles. This is good for us as a community.

ColdFusion 8 does not abandon the interface side of things though. There are a bunch of new display management tags including <cflayoutarea>, <cfpod>, <cfmenu>, <cftooltip>, <cflayout>, <cfmenuitem>, <cfwindow>. This shows that ColdFusion is still trying to make it easier to do things that everyone has to do. This time, they are clearly going after the interactivity of "Ajaxy" sites. Now, in the past, in ColdFusion, these types of interfaces have not always been usable on a forward facing application. This is no longer the case. Not only do they look completely modern and professional by themselves. But if you don't like them, they can be styled by CSS.

Lastly on the Web 2.0 side of things, there is a <cffeed> tag. This makes both creating and consuming RSS or Atom XML feeds much, much easier. Not much to say about it, this is something that all of us have to do now, ColdFusion makes it easier.

ColdFusion 8 makes Administration Easier

The new ColdFusion Monitor tool is perhaps the best improvement to my job ColdFusion has ever made. The ability to track down an errant template is simply stunning. The ability to kill a running template is beyond stunning, it's ginormous. You can actually see the stack trace of a running template if it's causing a problem. You can even see every variable in every conceivable scope in a request. This is truly stunning.

Even though we central administrators love exercising iron-fisted control over our shared servers, it's really nice for Adobe to open up limited capabilities of the administrator to distributed users. I do wish they had made it easier to tie it into a third party directory tool like Active Directory, but I'll take what I can get.

Finally the administrator now has more options for tweaking performance. You can set limits on number of simultaneous page requests, CFC calls, Flash Remoting calls, and web service requests. All of these tweaks do make it easier for administrators to control their environments.

ColdFusion 8 makes Selling as an Enterprise Solution easier.

I've never been one to demand Java like features in ColdFusion. However there are a few areas, where it would be nice if more Java like behaviors were exposed. One case I'm talking about is file processing. ColdFusion 8 now lets you parse files line by line, instead of forcing you to load an entire file into memory at once. But that doesn't even mention the addition of native Zip tools, which now exist. Granted you could have always dropped down into Java to handle this stuff, but the more you force that to be a solution for people, the more entry-level programmers that run into walls.

But, ColdFusion 8 doesn't just play with Java better. Adobe's been hanging out in Redmond. First ColdFusion 8 can call .Net objects like it can Java classes or CFC's. I think a little cooler, is the fact that ColdFusion 8 can talk with Exchange. Granted, I'm a little sad to be out of an expertise, but happy that everyone can now play with Microsoft's groupware offering. I'll probably be saying even more on this feature in the upcoming weeks. But make no mistake about it, this is hands down the easiest way interact with Exchange other than Outlook. It's really, seriously, that good.

There's a lot of touting of the performance enhancements to ColdFusion 8. But in addition to just running faster, ColdFusion 8 allows developers to have more control over the performance of their applications through the addition of <cfthread>. This technology will allow developers optimize sequential behaviors like emailing, or rebuilding static files by running them asynchronously. Up until now, the only clean option for asynchronous operations was the Asynchronous CFML Gateway. It does the job, but is a little unwieldy to use if you aren't an administrator on the machine. <Cfthread> doesn't replace the Asynchronous CFML Gateway, it just allows another option in the continuum of asynchronous operations.

All in all, developers can now make faster performing applications, on a faster platform, which can talk to many more systems now.

Conclusion

This is just the tip of the iceberg. Every one of these one sentence blurbs represents a feature that deserves its own blog post. (They also probably represent years of developer's time.) Additionally there are a ton of features, functions and tags I didn't mention. This is by far the best release of ColdFusion yet.

May 30, 2007 Posted by Terrence Ryan at 10:55 PM

Comments (2) | TrackBack (0)

ColdFusion, Web Development,

Get Your ColdFusion 8

Adobe has released ColdFusion 8 as a Release Candidate on Labs.

Go get some, it rocks.

May 30, 2007 Posted by Terrence Ryan at 12:45 AM

Comments (0) | TrackBack (0)

ColdFusion, Web Development,

La Aroma de Cuba Robusto

May 28, 2007

Yet another cigar review... after the jump.

Continue reading "La Aroma de Cuba Robusto"

May 28, 2007 Posted by Terrence Ryan at 4:54 PM

Comments (2) | TrackBack (0)

Cigar Reviews, Cigars,

Expecting

I've waited a while to post this, figuring I've told all my family and we're past the danger zone, and my wife already blogged it. Janice is pregnant, and we're expecting our firstborn in November.

I'm filled with great fear and excitement, per the usual father-to-be commentary. I'm also filled with the slight feeling that someone's going to step in and say "No, you can't do this." It's made me a bit panicky about finances, and I think we're going to be moving to the suburbs this summer. (For those that know me well, you know what a bitter pill that is.) We're looking towards Collingswood, NJ, as it is the right price range, and distance from Philly, and the right proximity to free-babysitting.

We've seen the heartbeat on the ultrasound; we don't know the sex yet. We do have names picked out: John Patrick (Jack) for a boy, or Eleanor Leigh for a girl.

So, fatherhood is in my future. If you catch me looking with a patronizing look and saying something like "Being a father changes everything..." please feel free to punch me in the throat. Although, please no permanent injuries, I do have a child that I will have to feed.

May 28, 2007 Posted by Terrence Ryan at 4:53 PM

Comments (4) | TrackBack (0)

Personal,

Squidhead and CFUnit

May 24, 2007

I published a change to Squidhead earlier today that included an option for Squidhead to write its own unit tests today. These unit tests are compatible with and require CFUnit. Here's a little bit about the reasons behind this.

I originally started fooling around with unit testing because after drinking Pragmatic Programmer Kool-Aid, and attending cf.Objective, it was the next thing on my list. I figured I would be pulling them into Squidhead, as it's pretty easy to tell if Squidhead worked (the application is either written or not,) but it's hard to tell if the created application is working. So I started to write unit tests for my DAO Objects figuring it would be an easy place to start. Once I got one working, I realized it was relatively rule based and could stand to be generated itself.

What it does is:

• Create a mock struct of the record.
• Create a mock struct of the record slightly different from the first.
• Create a record from the mock record.
• Read it back and compares it to the source.
• Update it according to the different mock record.
• Read it back and compares it to the source.
• Delete the record
• Read again to make sure the item is gone.

All that is wrapped in a <cftransaction> making sure the thing never happened. Additionally it reads in and honors foreign key constraints. It's got some weaknesses: it doesn't like binaries or images; its smalldatetime check is only accurate to the hour; and there are probably more bugs lurking.

Now once I got them working, they were in, but what's the point for users of the application? One should expect that the parts work.

So to make this worthwhile I added some logic that will run any test that is in the test directory structure. So if you're using Squidhead and looking to dip your feet in the waters of CFunit or unit testing in general here's your chance.

If you're wondering why CFUnit, and not CFCUnit, it's because as far as I can tell CFCUnit requires Mach II, and I figured one requirement was better than two.

So if anyone has any suggestion on how to test gateways or dao's I'd be curious. Otherwise check it out.

May 24, 2007 Posted by Terrence Ryan at 9:50 PM

Comments (7) | TrackBack (0)

ColdFusion, Squidhead, Web Development,

svnAuth.cfc

May 23, 2007

I figured I'd drop a line about a RIAForge project I just posted tonight.

It's pretty basic, but I figured there might be someone out there who would need the same thing. SvnAuth.cfc allows for programmatic interaction with Subversion authz files from ColdFusion. I know this might not be cool with the philosophy behind SVN. But I'm not really looking to prevent people from updating other people's projects, but rather preventing sensitive information (like datasource passwords) from being seen by people other than the developers.

Anyway, if you're in the small market for programmatic control of an SVN auth file from ColdFusion , check out svnAuth.cfc.

May 23, 2007 Posted by Terrence Ryan at 8:19 PM

Comments (0) | TrackBack (0)

ColdFusion, svnAuth.cfc,

Philly CFUG and Scorpio

May 15, 2007

Adam Lehman and Tim Buntel graced us with their presence at the Philly CFUG meeting tonight.

A couple things I really liked:

• Tim directly addressed the fear of the CF community that ColdFusion doesn't have a future. Basically "Look at everything we're positioning for the future! ColdFusion is the technology that we're using to drive them all!"
• Adam has really refined the examples he uses to explain each feature.
• Adam also really did a great job of answering earlier criticisms of <cfexchange> issues. (Not just the ones I leveled at him.)
• In general, I'm really impressed by the ability the CF road team shows to alter their presentation in response to the community. They're not just reading the same presentation to you. Well they are reading from the same presentation, but they've definitely changed the talk based on issues brought up by their audience.

figured I would take down the entire list of features discussed to date. Why? So I don't accidently mention a hypothetical to-date-unnamed feature, after the jump:

Continue reading "Philly CFUG and Scorpio"

May 15, 2007 Posted by Terrence Ryan at 7:58 PM

Comments (4) | TrackBack (0)

ColdFusion, Web Development,

Squidhead - 3 Big Additions

May 11, 2007

Over the last few days, between the inspiration I got from cf.Objective(), and some positive internal feedback regarding Squidhead, I was inspired to make some cool additions (Or what I consider cool editions.) I figured I would share.

Business Layer

Dave Konopka advocated for a layer between the DAO and UI for awhile, as I explain in my last Squidhead update. Well he finally got it. Basically it's the place where you want to put all of your logic for dealing with the objects as they will be interacted with by the UI.

XML Structure Cache

I wanted to do a few things to overcome the fact that the database is does not contain enough metadata to handle certain things. But I didn't want people to have to start with XML to start working with Squidhead. Solution: an XML version of the variable structure that Squidhead uses to generate all of the procedures, functions, cfc's, custom tags, and cfml pages for an application.

So what happens is that at some point you freeze changes on the database, then you set Squidhead to use the disk cache instead of the database. It will then allow you to change a couple of things in how the application works.

Currently you can only change three things (and have the change do something useful):

• DisplayName on database columns that will show as labels on all UI components instead of the name. ("First Name" vs f_name).
• OrderBy on tables which will alter the order of the default List elements
• ForeignKeyLabel the column which will be substituted for the primary key, in all tables that link to this table via foreign keys.

Which leads me to...

Foreign Key Support

Squidhead now understands foreign keys. Here's how it works:

Form UI - On forms that interact with tables with foreign keys, Squidhead will produce a select box of the aforementioned "foreign key labels."

List and Read UI- These components now call separate stored procedures that properly join the requisite tables to show the appropriate "foreign key label" in lieu of the actual value.

I haven't done anything with children objects or anything yet. Basically the change was to make the UI a little more useful.

My next pass of updates will be documentation related, as I've fallen behind.

Anyway give a try when you get a chance. Get it at RiaForge.

May 11, 2007 Posted by Terrence Ryan at 3:45 PM

Comments (0) | TrackBack (0)

ColdFusion, Squidhead, Web Development,

cf.Objective Afterthoughts

May 7, 2007

First off, it was an awesome conference for no other reason than I got to meet a whole bunch of people I know only by their blog, or blog comments. Second, I now get the allure of a Twitter back channel. (Even if it annoys some of the people on my Twitter list who aren't ColdFusion geeks.) Third, I haven't been this mentally stimulated by a work related conference, like ever.

This conference was awesome for the sheer access it gives attendees to the people who are leading our niche of web development. There's something very convincing about Mark Mandel advocating Transfer, or Joe Rinehart showing off Model-Glue:Flex. And there's something really entertaining about watching Mark Drew curse and compile his way through preparation for a CfEclipse demo.

But the biggest thought going through my head now is "What do I do, now that I know everything I do is wrong?" Granted that's an exaggeration of the truth, but it's certainly the feeling I have. But a more productive version of this question is "How do I introduce all of these great techniques into my regular work?"

Here's my list:

• Start using Coldspring
• Start using an ORM
  • Transfer
  • Reactor
  • A refined version of Squidhead (shameless plug)
• Start using a real framework
  • Fusebox
  • Mach II
  • ModeGlue
• Stop thinking about objects in terms of data
• Start doing development on my local machine
• Stop spreading rumors that the man saying he is Sean Corfield has the real Sean Corfield tied up in his hotel room.

That's a pretty tall order. Of course the smart thing to do would be to accept that there is no way that I can do all of this and therefore not try any of it. (Hold off that on that comment... I'm not just done yet.) So that's not a good attitude, but it isn't an uncommon one either.

I think the actually smart thing to do would be to accept that it's possible that I wouldn't implement all of these any time soon. However, I'm going to try and implement some of these things in bits and pieces where they make these most sense over the next few months.

I've already got a virtual server running a complete development environment, and I maintain that I never saw the real Sean Corfield this weekend...

Oh well, at least I managed to cross one of those off my list.

May 7, 2007 Posted by Terrence Ryan at 11:56 PM

Comments (12) | TrackBack (0)

ColdFusion, Web Development,

cf.Objective Day 3

May 6, 2007

Paul Kenney: Test driven Development with ColdFusion

Paul Kenney from Adobe took us through test driven development. Testing is one of those things that people (okay I) always nod their head and say "We totally should be doing that" and then do nothing about implementing. I was hoping to get some good incentives or strategies out of this session.

Paul started with the problems of testing. They basically boil down to:

• Too little
• Too late
• Too difficult to run (not automated)

Tips

• Programmer Tests (Unit Test)
  • Written by developer that writes the code
  • Written before the code that they test
  • Tests external behavior of components
  • Acts as a contact
  • No code without testing
  • Allow freedom to refactor
• Refactoring
  • Changing internal action of code without altering external behavior
  • Do so when principles of good object oriented design aren't being upheld
    • Duplication
    • Hard to understand
    • High Coupling
    • Low Cohesion
    • Too many switch statements
• cfcUnit
  • Errors versus Failures
    • Errors you know
    • Failures occur when code does not act as expected

Charlie Arehart: Understanding, Improving and Resolving Issues With Database Procedure Caches

Charlie Arehart is a really polished speaker. I'm not knocking anyone else, but he's just really smooth.

The main thrust of the talk was about getting optimized query plans through ColdFusion.

Points:

• Remember that there is a Database Management System between you and the database
  • Database driver
  • Connection Pool
  • DB Page buffers
  • Query Plans - Prepared Statement plan
• Use SQL Profiler
  • You can see Execution plans
• DB Plan caching
  • Reduces the amount of processing DBMS does
  • Instead of computing new plan, it reuses old one.
• Some of this data is available in perf monitor.
• Use the DBCC stuff in SQL 2005
• Performance Implications
  • Cache requires memory on CF
  • Not using it requires processor on SQL
• MySQL can do some of this now
  • Couple Gotchas
• SQL 2005 might not work if you are using compatibility mode
• Prepared Statements can hurt sometimes
  • When selecting by NULLS

Ben Forta: Keynote Top Secret Scorpio

Ben went over the Adobe buy out and customer worries to start with. He then went into the marketing over view:

• Developer Productivity
• Integration
• Management and Administration

Ben talked about three things to do with Developers and Eclipse

First was the ColdFusion Ajax Application Wizard. Much like the Flex application wizard it creates a simple application using Ajax. He also pointed out the ColdFusion Ajaz Debugging tool. You know how PHP programmers will grudgingly admit that ColdFusion does debugging much better than anything else out there. They're going to have to say it some more; because this thing is awesome.

Second was the Eclipsed based ColdFusion Debugger. This feature has never really excited me. But seeing it in action, I can really see it being useful.

Third was the new integration of Flex Data Service into ColdFusion. It's now being called LiveCycle Data Services.

• New gateway for pushing data to LCDS from ColdFusion
• LCDS is now part of the ColdFusion Install.
• Data Services can be consumed by technologies other than Flex.

Lunch

Hal Helms: Object Oriented Modeling

I went to the wrong room, and wandered into this, but didn't want to move because I had access to an outlet. Additionally, I've always wanted to hear Hal Helms talk.

This was a theoretical/philosophical discussion on the way to architect object oriented code around your data model. It was a very cool introduction about talking about this stuff better. The whole getter and setter model isn't enough. Don't think about objects in terms of data you can get out of them... Think objects in terms of what they do.

Hal starts at the UI and works down to the database. I guess, but I'm not sure, is that you have to shift your mind to thinking of the database as just a persistence layer to save object state. You have to ask yourself "What does it mean to be a <blank>?"

Hal's Tiers of OO Applications

• Data
• Domain Model
• Service Layer
• Application Layer

A lot of this went over my through my fractured attention span. My brain is full.

But cool notes:

• Favor composition over inheritance
• Feel free to make mistakes
• Separation of Concerns
• High cohesion
  • Well defined purpose
  • It should do only what it should do
• Low Coupling
  • Through API's instead of hard coded knowledge
• Design Patterns
  • They arose over time
  • Collected wisdom of the development world.

He finished up with a good example of why Inheritance is not the best pattern to use in many, many cases.

Chris Scott: Introduction to Aspect Oriented Programming with ColdSpring

Aspect Oriented programming is a relatively new comer to the programming world. It complements OO and controls wide reaching concerns. Chris Scott started talking about why we do it, before talking about how.

• Cross Cutting Concerns
  • Security
  • Transactions
  • Caching
  • Logging (Poster Child)
• Two central themes
  • Interception
    • Grabbing method calls (Join Points)
  • Introduction
    • Add functionality before, after, and around methods
    • Doing so is called Advising

This was another one that blew my mind.

He showed us an example of caching that was so robust, he took the database of a database application down, and it still worked. He also showed a great example of a use of custom metadata in CFC's.

After this I was done. Chris Scott hurt my brain. This stuff was so cool and so powerful, I want to use it. I just don't know where yet.

May 6, 2007 Posted by Terrence Ryan at 6:11 PM

Comments (1) | TrackBack (0)

ColdFusion, Web Development,

cf.Objective Day 2

May 5, 2007

The beds at the Sofitel almost made me miss my first session.

Matt Woodward: OO Architecture Back to Front

The focus of this session was developing OO architectures starting at the database and moving forward. Matt Woodward started with a quick overview of OO. One of the best things he explained was that all of the layers of an OO application serve to increase the coupling and decrease the cohesion of your application. He went over a few basic patterns like DAO, Gateways, Beans, etc, and a few layers like service, business, controller etc.

Interesting tips and pointers

• You want to do multiple layers of validation.
• Server side validation should probably live in the bean.

This was a really good presentation about the whys and wherefores of the multiple layer development style. He's going to post it up on his site. Definitely check it out if you get a chance. It would be a good tool to explain this stuff to others.

Steve Rittler: Using the Adobe Flex Toolkit for Apex

Steve Rittler's session wasn't announced. Being a fellow Philly ColdFusion guy, I figured I would give him some support. But it was so far outside my bailiwick that I figured I would be better served going to another session.

So I wandered into Adam Lehman's session.

Adam Lehman: Scorpio: Diagnostic Server Monitoring and Realtime Performance Alerts

Adam went over the server monitor, showing off what it could do.

He started with an overview of how this tool could be used in development. Since the server monitor shows how much memory all of your scopes are taking up, you can figure out the capacity of your application on your server. Very cool.

Cool Bites:

• The server monitor has a force garbage collection button
• Reports show the effectiveness of the query cache
• You can see how the database connection pool is being used and queued
• Configurable alerts so you can be notified if there are speed or responsiveness problems
• Alerts can take snapshot dumps of the environment for troubleshooting after the fact
• Configurable actions you can map to alert items. Like killing threads, or stop accepting requests
• Multiserver monitoring panel will allow you to see status of all your ColdFusion servers at once

Sean Corfield: Real World SOA: Building Services With ColdSpring and Transfer

Despite persistent rumors that he was an impostor, Sean Corfield took the stage to talk about Real World SOA's. SOA's = API's is a good way to think about this stuff. Things have to be done differently. Sean went over these difference.

SOA is about more than services. You need to have clearly defined data. Basically you need to agree on the same semantics when you talk about data, and the same components. For the most part you really have to document these applications, and then actually make this information available.

Software as a Service (SaaS) is growing as a market at 20 per year. SOA's are the backbone of SaaS.

Separation of concerns is very important to be doing this type of application. The future of this space will be light application that call SOA's that don't have their own view or controller. These SOA's are all Model.

Tips:

• Don't rely on client scopes
  • Session
  • Cookie
  • Client
• In fact turn the session scope off in your application
• Create some sort of token handling using a persistent store (database)
• Remember that ColdFusion makes data easy to manage
  • Other technologies don't handle Queries
  • Keep data types simple
  • Typed structs are good
  • XML
• You actually might need to use the This scope and <cfproperty>
• Sean has made a Rest adapter, you can download at his site.
• You don't want to just set access=Remote on your entire business layer.
  • Build a remote api instead
  • Might need to build API's for multiple technology
• Unit Testing is necessary
• Exceptions need to be handled differently
  • Fail gracefully
  • Return structured error message with fault indicator
  • Make sure that you throw codes along with text (because of internationalization.)
• Clustering and Caching is a challenge
• Tools to use:
  • ColdSpring
    • Manages the CFC's
    • Manages Transfer
  • Transfer
    • Manages the database
    • Handles all of the persistence of the application.
  • cfcUnit
    • Write tests
    • Automate tests
• What worked well
  • Unit Testing
  • Managing the CFC's and database with ColdSpring and Transfer
  • Automated builds
  • Cruise Control
• What went not so good
  • Using an old model for new work
  • Too many endpoints in the exposed API
  • Not enough unit testing

Lunch

Simeon Bateman: Fusebox the Original ColdFusion Framework

Simeon Bateman thinks that you should be using a framework, even your own. But he thinks that Fusebox is the best. I decided to go to this because some bad Fusebox code was what originally made me dislike Frameworks. Now that I've come around I figured I would give it another look.

Simeon took us from the beginning of Fusebox to the current day.

It was basically a good introduction to Fusebox. I had no interest in using Fusebox before this session; I now want to give it a try.

Break

I had a lull between sessions I wanted to attend. Evidently Jason Delmore's wife told him that I said I was annoyed with him yesterday. Poop. I didn't want to do that. I was mostly happy with what he had to say. There was much more positive than negative.

Additionally, Jason also helped saved someone's life yesterday, He was a total hero! He has that going for him.

Kelly Brown: JVM Server Tuning

I finished up the day with the very geeky JVM session with Kelly Brown. It was altered into a ColdFusion Performance Tuning session. I guess he extended it beyond where he initially intended it.

Concepts he went over:

• Disk Based
  • Trusted Cache
  • Deleting saved class files
    • Finding them can be slower than compiling
    • Dependent on hardware and size of site
• Memory based
  • A lot of these are tough because you control the number of items not size of memory footprint.
  • Maximum Number of cached template
    • Sweet spot
      • Too high - runn out of memory
      • Too low - performance issues
  • Maximun number of cached queries
  • Session and application scope
    • Session's can be wrecked by search engines so watch OnSessionStart
  • Mail and Charting can be cached too.
  • JVM tuning
    • You can change the memory footprint of the JVM
    • Jvm.config is where you can set a whole bunch of settings.
    • Change the JVM's JDK to improve performance.
      • Certified to 1.4.2_11.
      • Rumors of 1.4.2_13
    • Max Heap Size:
      • 512mb default to low number of Gb depending on platform.
      • If you are seeing memory errors set this higher.
    • A lot of JVM settings will never need to be touched. Especially in CF 7.
    • You can check JVM through the java.lang.Runtime
  • Sun Virtual Garbage Collector tool.
    • Free download from SUN
    • Part of jvmstat
• Processor Based
  • Simultaneous requests
    • His experience 15-20 per processor
    • Optimal depends on application.
    • Too high you spend more time switching out threads then processor
    • Too low, you don't get anything done.
  • Request Timeouts
  • Report and Charting threads
• Jrun.xml
  • Edit away
  • But make a backup first.
• Jrun Proxy Service
  • Connects Jrun to Webserver
• Scheduler Service
  • Also allows thread manipulation
• Load Testing
• Final thoughts
  • Don't turn on debug in production
  • Update database drivers
  • Don't put client variables in registry.

All in all, today was another day that hurt my brain.

May 5, 2007 Posted by Terrence Ryan at 6:11 PM

Comments (4) | TrackBack (0)

ColdFusion, Web Development,

cf.Objective Day 1

May 4, 2007

Keynote

Jason Delmore delivered the keynote the really gave a good overview of the philosophy around Scorpio. Adam Lehman was evidently worried about Jason's lack of "marketingese" but I really liked him admitting that the use cases for things like <cfpresentation> and <cfreport> were hard to find.

New confirmed developments include <cfthread> and <cffeed>.

I was a little annoyed with Jason's response to my question. I asked "Is the Beta feature complete?" He gave me a hard time and cited the NDA. I could have just asked. "If I'm on the beta will you say anything new?" But I was trying to be nice.

Mark Mandel: Developing Applications with Transfer ORM

This was basically a good introduction to using Transfer. Mark Mandel did a really good job speaking. What I can't figure out is the main difference between Transfer and Reactor. I'm not saying there isn't one. I just wonder if there is anything that one does that the other doesn't do or vice versa.

If only I had access to Mark Mandel and ask him without being an ass about it. (Remember to ask before any receptions or parties tonight.)

Dean Saxe: Application Security and Compliance

Dean Saxe's presentation on security looked really promising. This is why I signed up for it. What I heard of it was good. However Sean's twitters about David Keith's session lured me out.

David Keith: Adobe.com

This was a great opportunity to find out how Adobe runs their site. They use a heavily tiered environment on both the hardware and application side. It validated what we do at Wharton a lot, which I was happy about.

They were also upfont about their weaknesses which was also very helpful. They talked about their single point of failure at the database level, and problems with colliding scheduled tasks.

Lunch

Sean Corfield: AJAX Integration With Scorpio!

Sean Corfield gave this talk despite the fact that he not an Adobe employee (and despite rumors that he was not in fact the real Sean Corfield.)

Interesting little trivia bit - AJAX came out of advancements cause by Outlook Web Access.

Cool features:

• CFC Proxies in JavaScript, automatically
• Yahoo UI controls
• Databinding across controls
• Rich Text textarea's
• Auto Suggests

New Tags:

• <cflayout>
• <cftooltip>

At this point in the presentation Mark Drew started showing me his Project Unity stuff. Since I've seen a lot of what Sean was doing in the Beta, I paid attention to Mark Drew instead.

Adam Lehman: Scorpio: Working with .NET and Microsoft Exchange

Called the audible twice and decided to stay with what brought me to CF in the first place: Microsoft Exchange.

Adam spelled out the different ways that you can currently interact with .Net. Things like webservices, and various other types of wrappers. ColdFusion 8 will allow you to call .Net assemblies like CFC's or Java classes. Additionally it will perform better than all the other wrapper methods. On the backend ColdFusion creates proxies, much like webservices use skeleton objects on the backend.

He then went on to the Exchange technologies. Claim: ColdFusion Exchange tags can do anything that the Outlook Client can. Eh, not really, but it can do everything that you would want to build an application around. You can manipulate contacts, appointments, mail items, and tasks. You can't interact with say the Out Of Office message. "You can do anything to the objects CF exposes that you can do in Outlook" would be more accurate.

Interesting Ideas:

• .Net interaction will allow CF to extend Sharepoint.
• .Net interaction will allow CF to interact with IIS

Mark Drew: The CFEclipse Project

Mark Drew confirmed that he was never on the show 24. He then took as on an overview of the CFEclipse project.

Most of the people here are using CFEclipse, so he powered through the existing features. He spent a fair amount of time showing off Snippets which definitely are powerful.

Then he revealed Project Unity. Which I'm pretty sure is the killer application for CFEclpise. It's a CFFramework inspector that allows developers to basically interact with Frameworks through a variety of methods. One method looks a lot like the Component Explorer, but it also allows snippet like inserts of calls to Framework components.

What's really cool about it is that it understands the frameworks. So if you inspect a Fusebox project you can inspect individual circuits. If you inspect a Reactor project you can wire together relationships. In addition to viewing them, you can also edit them through a wizrd view that writes the code for you.

Finally it's full extensible, so if you have a framework, you can write your own XML to make it work with the CFframework explorer.

The key question is: When will it be released?

I figure I'll blog about the Birds of a Feather session after than tonight.

May 4, 2007 Posted by Terrence Ryan at 6:05 PM

Comments (5) | TrackBack (0)

ColdFusion, Web Development,

cf.Objective Day 0

Well, festivities kicked off tonight with the registration and reception.

Nothing major happened, except that Dave and I confirmed once and for all that Mark Drew did not really hire Carlo Rota to narrate CFEclipse.tv. Hear that John P?

Granted, that's not really major.

May 4, 2007 Posted by Terrence Ryan at 12:57 AM

Comments (0) | TrackBack (0)

ColdFusion, Web Development,

Squidhead Update 5/2007

May 2, 2007

Squidhead is swimming along nicely. I've gotten some good suggestions, over the last few weeks, and figured I would post what's going on.

Dave Konopka, who works with me here at Wharton, has a pretty good complaint about Squidhead. Basically his complaint is that there needs to be another layer between the DAO and UI. We've taken to calling it the Business layer. Basically, many times his basic interaction with the database requires more than just one DAO operation, and often other operations not related to the database (logging, email, etc.) So to achieve perfect encapsulation and reusability through the application, he requires the business layer.

He provided me with a good bit of code for it, which will create Business beans for any of the DAO operations. Additionally it abstracts the whole "Is it an add or is it an update" logic, making the UI have to do less work.

I've added the business CFC creation routine to Squidhead and am working on rewiring the UI to use it. It will be optional, so that existing applications don't break, but it will be set to the default way of doing stuff.

Finally, I did get some requests for Fusebox integration, and MySQL compatibility. I'm working on those, but Dave's in my office, so he gets to sell me this stuff right to my face.

May 2, 2007 Posted by Terrence Ryan at 11:47 AM

Comments (3) | TrackBack (0)

ColdFusion, Squidhead, Web Development,

My cf.Objective Schedule

All the cool kids are doing it, so I figured I would share my cf.Objective schedule with the world. The twist is that I extracted it from my Outlook calendar using the new Exchange tags in Scorpio. I've included the code below.

Continue reading "My cf.Objective Schedule"

May 2, 2007 Posted by Terrence Ryan at 11:05 AM

Comments (0) | TrackBack (0)

ColdFusion, Web Development,