Specification Pepsi Openindiana Build 148

1. How much energy does the entire machine use?

   On initial boot with the Samsung Optical SH-223L/BEBS spinning up we hit 95 watts, the system then drops to about 50 watts and as it idles out drops to between 47 and 48 watts. While pushing the machine using all 4 drives as stated in the spec, we fluctuate between 50 and 57 watts.

2. Why the 750w ATX Power supply?

   Based on the above data the 750w would seem to be overkill but in my specific case I have multiple units plugged into the motherboard. If one doesn’t plan on adding more than 4-6 hard drives you could easily get away with a 200-250 watt power supply. I’m going to search around for one and update the original specification.

3. Do you need to have the optical drive?

   Not necessarily, you could technically remove the optical drive after install of the specification if you wanted to save on initial start up power. However the unit spins up only on start-up and considering it will be rarely if ever used, it’s pretty much a complete non-issue.

4. No ECC memory, will that be an issue?

   In the original specification I noted the addition of ECC memory. Well, the Intel D5x doesn’t support ECC memory most likely to save as much energy as possible. It also doesn’t support Dual Channel memory, again for the same reason. Not the biggest deal in the world for this machine as it’s primarily used for storage and technically speaking the likelyhood of getting severe degradation or errors are low. Still, it would of been a nice to have. To my knowledge I don’t know of any mini-itx motherboard manufacturers that support ECC memory. At least not yet.

5. Instead of the D510, why not the D525?

   Well, if we take a quick look at a comparison between the D510 and the D525 we see that we gain a minute speed bump in processing and DDR3 instead of DDR2 and wattage remains unchanged. None of this quite frankly mattered to me at the time as the D510 was roughly $20.00 USD less. None of the stated improvements would significantly speed up the function of archival and storage. This obviously changes if you plan to do compression or encryption with ZFS in which case it may then become useful. In reality though it would make much more sense to apply that extra $20.00 USD to a proper gzip or encryption off-board card.

6. How much will it cost you to operate this unit?

   I pay roughly 9 cents per kwh off the top of my head. I’ll have to update with exacts next time I check but based on that number we are looking at close to $3.05 USD per month with the machine running at an average of 0.47kw/h or roughly $37.00 USD a year. Not such a horrible price for the machine that backs up my lively hood. Not that bad at all.

Share/Bookmark

Specification Pepsi Openindiana Build 148

The machine is named ‘pepsi’ and consist of the following hardware (all prices are current as of 03/22/2011):

• Lian LI PC-Q08B Black Aluminum Mini-ITX Tower Computer Case – $119.00 USD – Optional
• Intel BOXD525MW Intel Atom D525@ 1.8GHz (Dual Core) BGA559 Intel NM10 Mini ITX Motherboard/CPU Combo- $79.99 USD
• Custom SATA card built to my specifications – $PRICELESS
• Vantec 6-Port SATA II 150 Pci Host Card Model UGT-ST310R – $31.99 USD
• Corsair 2GB 240-Pin DDR2 SDRAM DDR2 800 Model VS2GB800D2 G – $29.99 USD
• Zalman F3 FDB 120mm Fluid Dynamic Bearing Case Fan – $12.99 USD – Optional
• Cooler master R4 Silent 140mm Case Fan R4-S4S-10AK-GP –  $11.99 USD – Optional
• Cooler master GX series 750W ATX Power Supply RS570-ACAAE3-US – $100.00 USD  *
• Samsung DVD+RW Optical drive SH-S223L/BEBS – $28.54 – Optional
• 2x Western Digital 1TB *
• 2x Western Digital 320GB *

* This item is to be part of a refactor meaning that this was originally built for my needs but one doesn’t actually need 750 Watts for power and can get by with a 200-250W power supply. Also not included is the price of the 4 hard drives as these are what I had in the original pool. In this case a sufficient comparable HD should do and not fall to far out of bounds in regards to power requirements.

Software wise we have:

• OpenIndiana Build 148 x86

A couple of things to note here on the machine build. The BIOS for the D510 Intel NM10 needed to be upgraded to the latest version as the board I ordered and received was almost a year behind in updates. Newegg did get the delivery to me within 1 day of ordering however which was blazingly fast considering. The fans were ordered because the case comes with a 120 and 140mm fan. The 120mm fan isn’t that loud but the 140mm fan has blue leds, which I simply have no tolerance for. The D510 mini-itx board itself is amazingly small and includes a mini pcie port that I can eventually stash a mini pcie wireless card in.

Also, the Vantec 6-Port has 4 internal sata ports and 2 external ESATA ports. It’s powered by the SiS 3114 raid controller which is basically some hodge podge mess onboard. They provide a straight-through IDE BIOS upgrade for the chipset available from the Silicon Image manufacturers website. You will need this if you want to use this chipset under OpenIndiana primarily because it doesn’t automatically detect this chipset otherwise. Moving from sata to ide may mean no hot-swap but I haven’t necessarily tried this yet. I’ll update after I hook up another 4TB store, i’m moving the data around now as we speak.

Luckily my custom board wasn’t damaged and all of the data on disk were fine. I am currently not at liberty to discuss the custom add-on board but hopefully i’ll remember to revisit this post when I am.

Normally I only buy ECC ram however to keep cost low and because I had verified my data wasn’t severely damaged, I have foregone the option for this machine. After some burn-in time I will most likely upgrade to an ECC ram module.

Before the hardware failure the most critical and important pool was my research pool which was a RAIDZ 1TB zfs pool. After installing OpenIndiana and setting up netatalk which now supports Time Machine backup I simply did a zfs import -f poolname and was back in business.

Share/Bookmark

I haven’t written any functional tutorial or such for Plone in a while. I’m working on a paper involving openid and started some work on an introduction to object and dynamic publishing that I need more time to work on, have random other things moving and etc excuses here. Something quick and useful in the meantime I suppose.

What is div blocking?

Div blocking is what I’m calling the process of returning a CoookedBody() back to your template into a specific html div. It’s not specific to plone and it’s a simple and straight-forward method many Plone developers call on. The idea is that you want to be able to return a section of html back into your overall template using a “Page” or “Document” content type. A simple use case for this is when you want to allow content-editors a chance to change something in the overall webpage using the standard Plone page content type. No sense in creating a new content-type just to return some formatted structured text. The end result is that you would like the final rendered html from that page to fit in-between <div></div> tags and for the overall look to leave your layout alone.CookedBody() is a method that is apart of the overall Document object located in the Products.CMFDefault egg. It is an accessor method and it looks like this:

    #
    #   IDocument methods
    #   

    security.declareProtected(View, 'CookedBody')
    def CookedBody(self, stx_level=None, setlevel=0, rest_level=None):
        """ Get the "cooked" (ready for presentation) form of the text.

        The prepared basic rendering of an object.  For Documents, this
        means pre-rendered structured text, or what was between the
         tags of HTML.

        If the format is html, and 'stx_level' or 'rest_level' are not
        passed in or is the same as the object's current settings, return
        the cached cooked text.  Otherwise, recook.  If we recook and
        'setlevel' is true, then set the recooked text and stx_level or
        rest_level on the object.
        """
        if (
            (self.text_format == 'html' or self.text_format == 'plain'
            or (stx_level is None)
            or (stx_level == self._stx_level))
            and
            ((rest_level is None)
            or (rest_level == self._rest_level))
            ):
            return self.cooked_text
        elif rest_level is not None:
            cooked = ReST(self.text, initial_header_level=rest_level)
            if setlevel:
                self._rest_level = rest_level
                self.cooked_text = cooked
            return cooked
        else:
            cooked = stx2html(self.text, level=stx_level, header=0)
            if setlevel:
                self._stx_level = stx_level
                self.cooked_text = cooked
            return cooked

Reading the documentation of the object method we can see that it returns the cached cooked text which is stored in Plone’s portal_catalog. One can go ahead and set stx_level or rest_level if you want which will use the reStructuredText parser to get you what you want.

I’m normally using a custom template in the form of a BrowserView and very rarely am I utilizing Plone’s default theme. So if you know nothing about BrowserViews then please read the previous link first.

How to do?

Pretty simple, you just get the page object that you are looking for and run CookedBody(). So create a page and let’s call it “Example” and fill it with some content. From there in creating your BrowserView lets add the method getTextFromPage() which will take the content from the page Example and return the CookedBody.

class MySpecialThemeView(BrowserView):

    implements(IMySpecialThemeView):

    def getTextFromPage(self):
    """Get the structured text from a page object with the id/name Example"""

        # We grab the root of our site here
        root = self.portal_eroor.getPortalObject()

        # We then grab the page object with the id Example
        example = getattr(root, "Example")

        # We then grab the body of the page as that is where the content lies
        # We could just as easily grab the title of the page or other attributes if needed
        body = example.CookedBody()

        # We then return body to our web browser
        return body

That finished our template would resemble something like:

HTML Template for CookedBody

Where right at the top of the page we have the div named example. That’s pretty much it!

Share/Bookmark

Víctor Fernandez de Alba

When Packt asked me to review this book I have to honestly say that I wasn’t looking forward to it. Plone as a product has a notorious track record for what I believe to be not the friendliest or most accessible documentation. Regardless of it’s technical superiority and usability, it’s a glaring deficiency. This is getting better with time but there is still a lot of work to do. Unfortunately my apprehension was filled with curiosity and I agreed to do so at one of the busiest times for me. That and the fact that instead of going on another tirade about documentation it would probably be useful to use my own guidelines in reviewing the book.

Nutshell for the impatient.

For those of you that cannot wait, have ADD, or TLDR syndrome here’s a short summary. Actually, this may come as a shock but I really enjoyed the book. My initial wanton and disregard was primarily for Chapter 8 but clearly it was simply due to context. Packt should really not use that as a sample chapter for this book, it’s a complete turn off for several reasons. I will pass that gripe along. That said, there are some tidbits in this book that really make it a good reference manual and a keeper for at least a little while. In regard to technical documentation that means it’s something you probably want on your shelf if you’re doing anything with Plone and intranets in the forseeable future. Quite frankly the book should be updated in minor fashion with a subsequent release for Plone 4 as not much has changed and it will help to get the book in hands of more new administrators and users of Plone. With some very minor changes this book could be called Plone 4 Intranets. This issue was most likely do to time constraints as Plone 4 has only recently been released. The intended audience for this book is administrators or new users who tend to do their own administration and I think it’s successful in reaching that audience. That said on a scale of 1 – 10 I give the book a strong 7.

Chapter 1

The introduction gives a good general background to Plone and how it came into existence. Discussing the excellent security track record of the CMS and it’s general history up until present. It then begins to segue into the more complicated but powerful features of Plone. Workflow, States and Transitions. This chapter also covers and introduces Python and ZODB (Zope Object Database) and why they are useful not only to Plone but to the entire content management space. It’s short-and-sweet providing just enough information and background to make it useful to the reader.  There is also a nice overview of the Plone community which introduces the reader to the entire community with a great handshake and welcome that is actually quite refreshing. An introduction on the fine line between extranet and intranets and how the spaces merge in some use case is a great cap for this chapter.

Chapter 2

Some introduction to the ZMI (Zope Management Interface) and a discussion of blob file types with no background was a bit too early I believe. The issue is that blob file types are native to Plone 4 and not Plone 3. It’s again an issue of time constraint and it must of been difficult for Victor to find the right balance between the two versions but I just don’t think the mention of the information was relevant here. Also even though ZMI is explained in detail it will be a little hard for non-technical users to fully grasp. The installation of Plone is shown with the Buildout system instead of the unified installer as a first option which I felt was a little hard to swallow as well. For non Plone users this will all seem foreign extremely early on in the book. However the book shines in guides for installing with the unified installer on the major operating systems environments. This really should have been outlined before the buildout instruction but even there the documentation is precise. The explanation of buildout and how it functions is really good and it takes you down into the specific sections for each buildout configuration which is quite handy. If you don’t know how to install Plone or have been having trouble you can follow along step-by-step with these instruction.

All in all Chapter 2 feels a little abbreviated and some of the concepts I felt should have been introduced through a relevant example in using them. If you are well versed in Plone it may seem rote here but will make good printed reference material for buildout. Otherwise this chapter maybe slighty confusing to a completely new administrator of Plone. If as a new user you aren’t readily thrown off by Buildout introduction you’ve survived one of the more difficult chapters. Also there is no dire need to use buildout. If you are confused then I recommend reading the sections for the unified installer specified for your operating system and it should help you along digesting some of the concepts.

Chapter 3

The chapter starts off with creating a Plone site named “intranet”. That one example would of been wholly useful as a step through from Chapter 2. That said this chapter gives a great overview of the breakdown of the default Plone theme installed with Plone 3. This has since been replaced in Plone 4 but that is pointed out in the chapter. We also get a well versed overview of the Plone user interface and how one can go about navigating it. As well as a few good examples on adding some of Plones default content types. This includes a walk-through and breakdown of the content structure and default hierarchy of a Plone site. The Dublin Core Metadata specification and good coverage of creating content in Plone is discussed. Including setting up content with some of the default content views. This chapter will certainly help the intended audience in navigation and use of Plone’s interface and it succeeds in a comprehensive overview here.

Chapter 4

In this chapter we deal with the configuration of Plone through it’s configlets. They are identified, explained and then broken down into a detailed explanation of usage. Good coverage of ZODB (Zope Object Database) packing via the maintenance configlet and the issues and concerns wrapped around that. There is also a section specifically page 65 which discusses the fact that Plone 4 has its own UI for site creation that simply feels a little out of place. The mention of this should have been in Chapter 3. Otherwise this chapter gives a great overview of the power of the ZMI (Zope Management Interface) and how it can affect site health if administered incorrectly. A valid and perfect apt warning as we delve deeper into the ZMI. For anyone well versed in Plone this is simply a fantastic overview of the ZMI and all of the objects related to Plone. Adding new products is also discussed in the two-way fashion. Meaning the old style products and the new standard de facto recommended procedure of using buildout and eggs (like zip files). The example given for eggs is really a poor one I believe. TinyMCE is native to Plone 4 and even though this book is specifically for Plone 3 one has to suspect that some users will just grab the latest package of Plone which will cause problems. Other than that this is a great chapter that begins to show you the power of Plone and the ZMI.

Chapter 5

This chapter begins one of the most important series of chapters in regards to Plone. Managing users and groups. The discussion on roles in Plone as well as the entire overview of the security system is excellent coverage of the topic that simply doesn’t get much mention at all. Even experienced Plone administrators or developers get confused about the setup from time to time. So for instance, the fact that roles are isolated so an editor who may have the rights to edit content may not have rights to explicitly read that content. For that you’d need to be granted the reader role. This chapter also covers how to create and manage a new user or group. There is also more coverage of administration through the ZMI to create user and groups. The author even clears up some common misconceptions that a new administrator to Plone may have such as confusing Plone PAS with the Zope PAS module. This is a solid meat and potatoes chapter.

Chapter 6

Next in this important series of chapters is Managing Workflows. This is probably one of the most critical and useful topics covered in this book. So far and up until this point there haven’t been many visual diagrams and explanations for the most part. With the exception of stepping through commands we don’t get much visual aid. This begins to change here as it begins to become necessary. There is great overview of workflows and what they are comprised of. Including coverage on out of the box workflows related with Plone. The difference between a state and a transition and what you can do with each specific action. There is also light discussion on tales/tal which exposes the lack of documentation on topics like ZPT (Zope Page Templates). The book does it’s best to provide a link but no coverage is giving there. Quite frankly one should be able to pickup another manual on ZPT or the likes but a comprehensive manual doesn’t really exist here.  We also talk about some third party add-on products for Plone primarily collective.workflowed, collective.wtf and DcWorkflowGraph which is simply a requirement if you are going to be doing anything with workflows. I really wish one tool was chosen instead a discussion of the three. Having the three divergent paths even though useful in the context of choice may confuse a new user should one of those paths fail. Otherwise this was an excellent chapter and worth the read even if you are an experienced Plone user, administrator or developer. This chapter along with the previous one make this book worth keeping as a reference manual.

Chapter 7

Security is important and this chapter covers securing the intranet. Concentrating primarily on permissions and workflows the chapter goes into great detail on converging what we have learned up until now in the previous chapters. The differences between Global and Local roles is great. I feel the discussion on Anonymous, Owner and Authenticated functional roles was a bit brief and needed much more detailed explanation. The coverage on actually creating and implementing a policy is pretty good. From outlining requirements, building an example intranet workflow, creating a private section for your intranet and even taking into account third party addon products security and settings you will be well versed towards this chapters end on security. This is also the chapter where we start to see a bit of python code that quite frankly is ok. There is a note, noting that basic product development will take place in Chapter 10. New users to Plone will most likely have to skip to this chapter to ramp up and immediately cover that background if they would like to continue following in earnest but it’s not absolutely necessary. There is also a discussion on collective.sharingroles at the end which nicely caps the chapter. I’m not sure if it’s absolutely required, but it’s a decent addition to the overall chapter.

Chapter 8

Using a content type effectively. This chapter in the context of reading the book is completely useful. Otherwise in the context of simply a sample chapter it’s useless. Quite frankly, there is nothing in this chapter that isn’t already on Plone.org in some fashion. This doesn’t exactly entice one to buy the book, as I read this as a sample chapter I said to myself, I have already read this stuff many a time over. Sans this one gripe in this chapter you’ll learn about creating collections and querying the ZODB (Zope Object Database). We also learn about the useful features of other out-of-the-box Plone content types. Other than that there is not much to say about this chapter. I wouldn’t have necessarily called it useful outside of the context of the book and even in context it’s more of a standard straight forward chapter.

Chapter 9

This is a nice progression from the previous chapter as it discusses external content-types and products that can be used with Plone. Most of these products are primarily for intranet purposes obviously and a good over view is given of each product. You have calendar, events, blog, survey, poll, document management and form generation products. In specific the form generation product covered is PloneFormGen and I’m pleased that this was the only thing covered on the topic of form generation. There are actually other different ways to create a form but the author picks one and sticks with it. An experienced user or administrator of Plone would be able to branch off where necessary. Also the discussion on the document management products is really quite useful for intranet settings. This chapter is great in introducing these add-on products that most intranets will need to use and gives a good overview of each different type of product.

Chapter 10

This chapters goal is to introduce the readers to the basics of Plone product development and I think it succeeds in that regard. It steps through the basics of creating and building a completely useful product. Obviously it’s not as comprehensive as my own documentation on the topic but it’s a very comprehensive take and is readable. GenericSetup the tool used to manage some of the major tool objects in Plone is broken down in detail and explained including a matrix of all the relevant xml and it’s subsequent description. There is even an example of cloning a content type with GenericSetup through the ZMI (Zope Management Interface).  The only issue with this chapter is any mention of Dexterity. Dexterity is on track to be a replacement/sister for Archetypes. Unfortunately there are some sacrifices that will be made and incompatibility with the previous Archetype system is unavoidable. Quite frankly Archetypes will be around for sometime to come and there was nothing useful to be had by even mentioning Dexterity in any context at this point in the book.

Chapter 11

Content rules are triggered based on Zope event handlers and this coverage is pretty decent you’ll learn how to create rules and have them triggered based on specific event. You’ll also learn how to create syndicated feeds from folderish content type objects. However the most important piece in this chapter will have to go to versioning. Versioning is an absolute requirement for any content management system and Plone has a simple and straight-forward way it handles changes to content. This chapter will give a great overview of how to use the versioning system as well as managing version policy. The WebDAV and External Editor coverage is also useful.

Chapter 12

Chapter 12 starts with the pronouncement “Theming — what a huge subject in Plone!” This is quite right as Plone and theming opens all avenue of possibility I was surprised to see this chapter in this book. After reading it and with the prior knowledge that there are numerous other manuals, reference material and books on the topic of Plone theming this chapter is in my opinion superfluous. All that stated the chapter does give a decent overview of theming Plone. Changing logos, managing viewlets describing the page render process and useful tools like Gloworm it makes itself a chapter of bonus material. Viewed in that context this again makes the book a solid and useful reference manual.

Chapter 13

This is simply a great chapter that discusses proper deployment of Plone for three different types of deployments. Victor goes into useful detail on site deployment describing it as a continuous process there are many different options and implementations but breaking the process down into 3 different deployment sizes is reachable. We have small 1-50, medium 50-100 and large 100+ every essential process for a working deployment is covered from backing up, restoring and packing the database to rotating log files, scheduling, virtual hosting, load balancing between ZEO clients for redundancy, caching and even externally authenticating against LDAP (Lightweight Directory Access Protocol). Each process has enough coverage to get any of your deployments off of the ground. The only thing that I think is missing from this chapter is a way to assess and manage performance which I would have easily given up chapter 12 for. All in all however the final chapter in this book is yet another solid and useful chapter in what has turned out to be a great and useful manual.

Recommendation

All things considered this book in so far as a technical manual is great coverage of the topic of Plone and Intranets. The author does an excellent job in conveying the material and even if you aren’t doing anything with intranets there are several solid chapters on Plone deployment, theming and others that make the book a solid purchase for anyone planning to use Plone for almost any application. I give the author my congrats and highly recommend it as a solid buy.

1. Should you need someone to tell you to chop up your project into smaller units that are more easily digested? You’re a bad manager/team lead/leader/whatever you are calling yourself. Needless to say a two or three year old is smarter than you and that MBA money went to waste.
2. If something is a smaller unit, that doesn’t make the problem you are trying to solve through programming or anything else any easier.
3. If you need someone to tell you that you need to sit down and discuss what you plan to do before you do it? You’re a bad manager/team lead/leader/whatever you are calling yourself.
4. If there are more bad than good things to say about something. It is rotten, throw it out.
5. No external force can run your company better than you and your employees.
6. Team building involves no methodology, it’s a constant reassessing and making tough decisions. You want to make your weak programmers strong and reward your stronger programmers appropriately. If you need someone to tell you this. You’re a bad manager/team lead/leader/whatever you are calling yourself.
7. If you are a programmer that can’t say “I don’t know, i’ve never done it before” or “This will take too long for X reasons” and/or “I don’t know anything about X”. Grow some backbone, you seriously aren’t all knowing either so stop acting like a dick.
8. If you are a manager practicing Agile in any context. You’re a bad manager/team lead/leader/whatever you are calling yourself.
9. There’s nothing Agile about agile; Work is work, someone has to do it no matter how you cut it up. Agile doesn’t make your resources work faster, more smoothly or any of that.  Building a comprehensive team does that; not some methodology.
10. Why can’t you all be like Google and have the best programmers/admins working for you? You don’t reward or pay a decent salary, and then on top of that you use crappy ass tools. Google is only successful because good programmers decide to work for Google; not because they have some secret sauce. That’s how it works for ANYTHING. When the best people want to work for you well then you’re gonna corner any market they are in. If all of Google’s programmers left tomorrow they’ll be a closed shop soon as those programmers go to Doogle.com or whatever.
11. How can I get the best programmers working for me? Choose the best tools and only the best tools. They will come looking for you; guaranteed. In your next job posting put “We like to use these tools, because they are the fucking best most awesome kickass tools available and we are building great shit.” Also, i’d recommend not having HR write up the copy and less the profanities. Keep it simple, short and to the point. See what type of reaction you get.
12. Software engineering is mentally draining. It’s not like filing papers. It isn’t rote, so you can’t treat your employees like it’s some factory line.
13. The best feedback you get is from your programmer and if he/she gives you a comprehensive reason on why X is horse shit and it makes sense. Heed that warning.
14. Here’s a typical stakeholder request. “I want to go to Mars”. Here’s a typical agile response “Lets break that story down into tasks and see how best we can do this if possible or break the overall problem into multiple sprints”. Here’s a typical Christopher Warner SW response “Well, I don’t know if i’m in the right room at present but this is not fucking NASA, there would have to be a lot of work to get there. Maybe you should think about getting to Florida first”.
15. Here’s a typical Agile question “If you’re in space and lost your tether and you had X tools which one would be best to use in aide of saving your life”. Here’s a typical agile response “The gun would be best”. Here’s a typical Christopher Warner response “You’re fucked”. It doesn’t matter what tools you have at that point. The idea is to NEVER lose your tether so you never have to make that decision.
16. How do I know I have a good programmer/admin? He or she is usually busy getting shit done, and pretty much needs little to no management. They tell you what’s going on, how things are progressing. What issues problems, concerns they may have etc. Pretty much everything is quiet on the front when they are around.
17. How do I get a team of good programmers? Good programmers will want to work with good programmers. Primarily because when one gets lost it pays to have a decent wing man or someone who can say “Welllllllsssssstttt this isn’t working because you’re a fucking idiot and wrote this module wrong, you’re a dumbass. We’ll work it out over lunch.. you know what?? lets finish this in X’s office she’s working on some similar shit; we’ll order up. Bang this out and then hit the gym, after the beer you buy me. It always taste different when you buy it”.
18. How do I reward my team? Contrary to popular belief, money is on the top of the list but sans that proper recognition. Beers and pizzas and all that shit, save it for highschool. At the very least offer expensive liquor, we are all adults here.
19. How can I be a better manager/team lead/leader/whatever you are calling yourself? Make sure the road is paved and fill in potholes. When something from the top comes down that is horse shit? Say “This is horse shit”. Don’t go back to your team with a “This is horse shit but we have no choice.”  Say “This is horse shit, I said it’s horse shit and I explained the detrimental waste of fucking time. They still want to do it. Of course, you guys are free to do something more awesome and when asked I’ll show them more awesome with a, my apologies, I guess this more awesome thing I have right here will have to suffice” or “Sorry we just can’t fucking do this stakeholders.. It’s just not possible for X reasons, the top one being that I know my job better than you and this request is simply in management lingo, UNpossible”. Wrap that in termination free language; unless you happen to be in a mood in which case have another job already lined up and be sure some of your team can come. Don’t want to abandon them.
20. “I don’t know anything about computers I just want a measurement of when I can expect things!” When it’s done, or accept variable estimates. Unless for some reason you believe the art of writing a program to be a measurable unit of work. In which case, let me explain. Writing a program is much like being an artist. You start with a blank canvas with a couple of constructs and then you have to take whatever came out of the human MIND and create a reality out of it. Think it’s easy? Think of anything you have never built before until now.. Now go build it, but before you do. Tell me when it’s gonna be done. I’ll wait.
21. Anything successful takes a long time of proper foundation building, team building and regression. If you don’t have that or experience it. You will not be successful. It’s that simple there is no methodology or luck involved besides hard work and building a good team. FOR ANYTHING.

Ok that’s enough. I hope you apply “Software Engineering” as a method to your next project; even if it isn’t software.