THE SQL Server Blog Spot on the Web

Welcome to SQLblog.com - The SQL Server blog spot on the web Sign in | |
in Search

Andy Leonard

Andy Leonard is CSO of Linchpin People and SQLPeople, an SSIS Trainer, Consultant, and developer; a Business Intelligence Markup Language (Biml) developer; SQL Server database and data warehouse developer, community mentor, engineer, and farmer. He is a co-author of SQL Server Integration Services Design Patterns and Managing Geeks - A Journey of Leading by Doing, and author of the Stairway to Integration Services.

  • What’s the Number One Attribute of Awesome Email?

    Brevity.

    :{>

    Learn more:

    Managing-Geeks-Cover-2003

  • SSIS Catalog Environments– Step 20 of the Stairway to Integration Services!

  • Consulting 101: Viewing the Field

    It’s important for a consultant to be able jump into a situation and quickly evaluate and assess the dynamics involved, in order to serve the client efficiently and effectively and economically. While a lot of people dislike military metaphors, there are a lot of good lessons to learn from military thinking. This is one area where military lessons can help, in my opinion.

    In his book, The Face of Battle, John Keegan writes about a skill:

    “…best described by the French word formation, aims if not to close his mind to unorthodox or difficult ideas, at least to stop it down to a fairly short focal length, to exclude from his field of vision everything that is irrelevant to his professional function, and to define all that he ought to see in a highly formal manner.”

    The general idea, fleshed out later in the book, is to view the current situation tactically, assessing the threat level of each component or “sub-situation” in terms of responses to potential actions of these actors. Formation is about prioritization with a bias for action. If you’ve read The Alchemist you know “beginner’s luck” is really a combination of the inevitability of opportunity combined with a bias for action.

    The ability to conduct a fast and accurate assessment of a situation is an important consulting skill.

    :{>

    Learn more:

    Managing-Geeks-Cover-2003

    Managing Geeks is available at Amazon in paperback and Kindle editions!

  • Interpreting Communication

    One important thing about which to be self-aware is how you interpret communication.

    Communication is a two-phase commit. The first part lies with the person communicating. She has an idea she wishes to communicate, and she communicates it – in writing or verbally. The second part is with the person (or people) to whom the communication is directed. He has just read her email or is listening to her speak and must now interpret what he’s read or heard.

    If all goes well, both parties agree on the message content and move forward. But if all does not go well?

    Misunderstanding

    Misunderstanding is one of the things that can go poorly in communication. Misunderstanding includes not hearing someone well enough, or misinterpreting what was said or written. This is one of the reasons businesses execute contracts: to make certain all parties understand their roles, responsibilities, and rewards. Agreeing in writing mitigates the opportunity for misunderstanding.

    Under-Communication

    When people in the know withhold information from others or partially deliver information, misinterpretation can ensue. Leaders should first consider the amount of information they desire to convey and then think about how to convey that information before delivering the message.

    Not communicating falls into the category of under-communication. One trait of effective leadership is communicating, period.

    Over-Communication

    It’s also possible to share “too much information.” In business, especially, everyone does not need to know everything. In fact, sharing too much in a volatile or otherwise developing circumstance con lead to confusion as information ages and becomes stale. Leaders should strive to communicate developing information to those who need to know and an after-the-fact summary to those who may be interested.

    Misinterpretation Ownership

    Who owns a misinterpretation? Returning to the example of she-said-he-heard, both parties own any misinterpretation. There are practices available to facilitate communication. Active listening is one technique whereby a listener speaks a paraphrase of what they heard back to the speaker. The speaker gets to hear what the listener thought they heard and can correct any misinterpretation or mis-speaking. Body language and vocal queues can be observed to make certain the message has been properly interpreted. This works well for voice conversations, but what about written communications?

    A challenging communication issue arises when one communicates in writing – via email, for example – and receives no response or a delayed response. How does a listener interpret no reply? One can assume the worst, that the listener is being dismissed or worse, completely ignored. This is often not the case, though. Thomas LaRock (blog | @SqlRockstar) offers trenchant advice on this scenario (and many similar scenarios) in his post titled What is Your McGuffin? What is Tom’s advice? “Assume good intentions.” Is, “I am being ignored” a good intention? Nope. How about, “I am being dismissed?” Not a chance.

    Is it possible leadership is failing to communicate because they are busy with stuff they consider a higher priority? Yep. Is it possible leadership is disorganized or has forgotten? Absolutely – especially if they’re leading a startup or opportunities for growth are regularly appearing.  But does that mean your idea is not important? Personally, I think that’s a stretch.

    The Key

    Regardless of how you interpret the actions – or inactions – of those with whom you communicate, the key is tolerance. If you are a leader, you should strive to communicate better and at the proper frequency – not too much or too little – and you must tolerate the interpretations of those with whom you communicate. If you are not a leader, you should also try to communicate more effectively. Leaders and non-leaders would do well to exercise Mr. LaRock’s excellent advice: Assume good intentions.

    :{>

  • Executing SSIS: Run SSIS Packages in the SSIS Catalog via Stored Procedure

    In my article titled A Custom Execution Method – Level 19 of the Stairway to Integration Services posted at SQL Server Central, I created a stored procedure to execute SSIS packages stored in the SSIS Catalog. Really, all I did was build a rudimentary wrapper for the stored procedures used by the SSIS Catalog to execute packages. To learn more about what I did, and why and how I did it, please read the article. It’s good. I promise. Would I lie?

    One benefit: the SSIS Catalog does not (easily) facilitate code re-use. If you want to execute the same package in multiple SSIS Catalog projects, the Execute Package Task is going to force you to import those packages into your existing project. What happens if you update this package later? You have to update every copy of the package… and then redeploy – and test – each project. Or, you can use an Execute SQL Task to call this stored procedure, and execute any SSIS package. In any project. In any folder.

    The Transact-SQL script that follows adds a stored procedure to the “custom” schema (please create the custom schema first) to the SSISDB database (the database used by the SSIS Catalog). It creates an intent-to-execute, configures the intent-to-execute, and then executes the SSIS package.

    Use SSISDB
    go

    print 'Custom.execute_catalog_package stored procedure'

    If Exists(Select s.name + '.' + p.name
              From   sys.procedures p
                     Join sys.schemas s
                       On s.schema_id = p.schema_id
              Where  s.name = 'custom'
                     And p.name = 'execute_catalog_package')
      begin
          print ' - Dropping custom.execute_catalog_package' 
          Drop Procedure custom.execute_catalog_package 
          print ' - Custom.execute_catalog_package dropped'
      end

    print ' - Creating custom.execute_catalog_package'
    go

    Create Procedure custom.execute_catalog_package
     
     @package_name    nvarchar(260),
      @folder_name     nvarchar(128),
      @project_name    nvarchar(128),
      @use32bitruntime bit = false,
      @reference_id    bigint = NULL,
      @logging_level   varchar(11) = 'Basic'
    As
      begin
          -- create an Intent-to-Execute
          declare @execution_id bigint

          exec [SSISDB].[catalog].[create_execution]
            @package_name=@package_name,
            @execution_id=@execution_id output,
            @folder_name=@folder_name,
            @project_name=@project_name,
            @use32bitruntime=@use32bitruntime,
            @reference_id=@reference_id

          -- Decode and configure the Logging Level
          declare @var0 smallint = Case
              When Upper(@logging_level) = 'NONE' Then 0
              When Upper(@logging_level) = 'PERFORMANCE' Then 2
              When Upper(@logging_level) = 'VERBOSE' Then 3
              Else 1 -- Basic
            End

          exec [SSISDB].[catalog].[set_execution_parameter_value]
            @execution_id,
            @object_type=50,
            @parameter_name=N'LOGGING_LEVEL',
            @parameter_value=@var0

          -- Start the execution
          exec [SSISDB].[catalog].[start_execution]
            @execution_id

          -- Return the execution_id
          Select @execution_id As execution_id
      end

    go

    print ' - Custom.execute_catalog_package created.'
    go 

    Use this handy stored procedure to execute SSIS packages via T-SQL, regardless of which SSIS Catalog folder and project contain the packages.

    Learn more:
    Advanced SSIS Training with Tim Mitchell and Andy Leonard in Dallas, TX 9-11 Mar 2015
    Watch the Video
    Get the Script
    Linchpin People Blog: SSIS
    Stairway to Integration Services

    SSIS2014DesignPatterns200

    :{>

  • Self-Awareness – Feedback

    Self-awareness is an important trait. I believe it is especially important for consultants.

    For each of us, there is some gap between reality and what we perceive. I believe one measure of humility (or pride) is this self-awareness delta. I also believe we can narrow this gap by engaging in exercises in intentional awareness. Which exercises?

    Seeking Feedback

    Asking others is a way of actively seeking feedback. I believe this requires confidence and thick skin, especially when the feedback we receive is negative.

    Listen to the Feedback

    This is especially true and simultaneously especially difficult of the negative feedback. You can choose to ignore negative feedback from mostly negative people. But consider that negative people are going to key on your (and everyone’s) faults, so don’t completely ignore their feedback.

    Consider the value of de-constructive criticism. One aspect of constructive criticism is that it’s communicated in a neutral manner, perhaps similar to coaching. News flash: not everyone is a coach. That doesn’t disqualify them from providing accurate – and perhaps useful – criticism.

    Apply Feedback

    I don’t know about you, but I don’t like hearing criticism. My initial reaction is not, “Awesome! Now I know where I can improve!” I doubt I will ever feel that way, but I think I should.

    I welcome your thoughts about self-awareness and feedback.

    :{>

  • Managing Geeks Now Available for the Kindle!

    Managing Geeks Cover 200

    Managing Geeks – A Journey of Leading by Doing is now available at Amazon in paperback and Kindle editions!

    Many people have expressed interest in obtaining an electronic copy of Managing Geeks. I’m sorry it took this long, but it is finally available. On a related note, I now know a lot more about self-publishing.

    The book is based on a 57-part blog series right here at SQLBlog.com. Started in 2009, the series is titled Managing Technical Teams. That was going to be the title of the book until our excellent editor, Karen Forster (LinkedIn), worked through the material. You should read “worked through the material” to mean “made the writing coherent and flow.” Karen is awesome. When Karen reached the post titled Human Doings, she wrote this comment:

    We might want to consider making this the introduction to the book. It captures what I think the book is about...
    In fact, something along the lines of ‘Human Doing: What You
    Are Makes You a Good Manager’ might be the germ of a new title. It needs work, but it could be a start.

    (Did I mention Karen is awesome?)

    Tim Radney (Blog | @tradney) is also awesome. Tim led the publishing effort at Linchpin Press. You could say Tim launched Linchpin Press, even – he and John Sterrett (Blog | @johnsterrett) co-authored the first book published, SQL Server 2014 Backup and Recovery. Tim’s brother, Todd Radney of Yesterday’s Photography, provided the cover art for SQL Server 2014 Backup and Recovery and Managing Geeks. Tim and Karen led us through the publishing process, and Linchpin Press was born!

    Thank you, Karen and Tim, for all your hard work. The results speak for themselves!

    :{>

  • A Custom Execution Method – Level 19 of the Stairway to Integration Services!

  • Administering SSIS: Security-related SSIS Questions

    I credit my friend and brother, Chris Yates (Blog | @YatesSQL), for inspiring me to write this post with his (excellent) post: Reports in SSIS.

    If I had a nickel for each time I’ve been asked, “What permissions are required for SSIS?” I would have a lot of nickels.

    It’s a fair question with an unfair answer, “It depends.”

    “It Depends on What?”

    Here are some considerations:

    • SSIS Execution
      • Who has permission to execute SSIS packages?
    • SSIS Administration
      • Who has permission to deploy, delete, import, and export SSIS packages?
      • Who has permissions to view SSIS Catalog reports?
    • SSIS Authentication
      • To which databases will SSIS packages need to connect?
    • SSIS Authorization
      • What functions will SSIS packages need to exercise once connected to resources?
    • SSIS Encryption
      • Is there a reason to encrypt the logic contained in the SSIS package?
    • SSIS Obfuscation
      • Does the SSIS package contain proprietary logic or intellectual property (IP)?
    • SSIS Maintenance and Revision
      • Who is authorized to update SSIS packages?
    • SSIS Testing
      • What is the process for testing SSIS packages?
      • Who performs SSIS package tests?

    These are some, but not all, considerations surrounding enterprise Data Integration Lifecycle Management (DILM) DevOps. A more detailed version of this list may be found in my post DevOps, Data Integration Lifecycle Management (DILM), and SSIS Security over on the Linchpin People Blog, which includes a link to download the full checklist in Word format.

    Learn more:
    Watch the Video
    DevOps, Data Integration Lifecycle Management (DILM), and SSIS Security
    Advanced SSIS Training with Tim Mitchell and Andy Leonard in Dallas, TX 9-11 Mar 2015
    Linchpin People Blog: SSIS
    Stairway to Integration Services

    SSIS2014DesignPatterns200

    :{>

  • Administering SSIS: Parsing SSIS Catalog Messages for Lookups

    "The SSIS Catalog is a database and an application." - Andy Leonard, circa 2015

    If there’s one thing I want you to get from this post, it’s this: The SSIS Catalog is a database and an application. While it’s a pretty cool database and application, it isn’t anything different from the databases and applications you support every day. As such, you can query and extend the database just like any other.

    One of the coolest features of the SSIS Catalog is the logging. You can select between four options:

    1. None
    2. Basic (the default)
    3. Performance
    4. Verbose

    The text of log messages are stored in the SSISDB database, in the internal.operation_messages table. The catalog.operation_messages view queries the internal_messages table.

    To parse a message string contained in the SSIS Catalog, I can use a T-SQL script similar to the one shown below. It will grab messages generated by the Lookup transformation from the catalog.operation_messages view and display some useful metrics. If I want to isolate the results to one execution of one SSIS package, I supply a value for the @operation_id parameter. If @operation_id is NULL (as shown below), all LookUp transformation messages will be parsed.

    This script does not account for NULLs,  division by zero, or partial data. It provides some handy metrics you will want to monitor as part of your enterprise Data Integration Lifecycle Management (DILM).

    Use SSISDB
    Go

    declare @LookupStringBeginsWith varchar(100) = 'The Lookup processed '
    declare @LookupStringBeginsWithSearchString varchar(100) = '%' + @LookupStringBeginsWith + '%'
    declare @ProcessingTimeString varchar(100) = 'The processing time was '
    declare @ProcessingTimeSearchString varchar(100) = '%' + @ProcessingTimeString + '%'
    declare @CacheUsedString varchar(100) = 'The cache used '
    declare @CacheUsedSearchString varchar(100) = '%' + @CacheUsedString + '%'
    declare @operation_id bigint = NULL

    Select
      operation_id
    , Substring(message,
                (PatIndex(@LookupStringBeginsWithSearchString, message) + Len(@LookupStringBeginsWith) + 1 ),
                 (
                  (CharIndex(' ',
                             message,
                             PatIndex(@LookupStringBeginsWithSearchString, message) + Len(@LookupStringBeginsWith) + 1))
                  -
                  (Patindex(@LookupStringBeginsWithSearchString, message) + Len(@LookupStringBeginsWith) + 1)
                 )
                ) As LookupRowsCount
    , Substring(message,
                (PatIndex(@ProcessingTimeSearchString, message) + Len(@ProcessingTimeString) + 1 ),
                 (
                  (CharIndex(' ',
                             message,
                             PatIndex(@ProcessingTimeSearchString, message) + Len(@ProcessingTimeString) + 1))
                  -
                  (PatIndex(@ProcessingTimeSearchString, message)+ Len(@ProcessingTimeString) + 1 )
                  )
                 ) As LookupProcessingTime
    , Convert(
              bigint,
              Substring(message, (Patindex(@LookupStringBeginsWithSearchString, message) + Len(@LookupStringBeginsWith) + 1 ),
                        (
                         (
                           Charindex(' ',
                                     message,
                                     Patindex(@LookupStringBeginsWithSearchString, message) + Len(@LookupStringBeginsWith) + 1)
                          )
                         -
                          (Patindex(@LookupStringBeginsWithSearchString, message)+ Len(@LookupStringBeginsWith) + 1 )
                         )
                       )
             )
              /
             Convert(Numeric(3, 3),
                     Substring(message,
                               (
                                Patindex(@ProcessingTimeSearchString, message) + Len(@ProcessingTimeString) + 1),
                               (
                                (Charindex(' ',
                                           message,
                                           Patindex(@ProcessingTimeSearchString, message) + Len(@ProcessingTimeString) + 1
                                          )
                                )
                                 -
                                (
                                 Patindex(@ProcessingTimeSearchString, message) + Len(@ProcessingTimeString) + 1
                                )
                               )
                              )
                    ) As LookupRowsPerSecond
    , Substring(message,
                (
                 Patindex(@CacheUsedSearchString, message) + Len(@CacheUsedString) + 1 ),
                 (
                  (Charindex(' ',
                             message,
                             Patindex(@CacheUsedSearchString, message) + Len(@CacheUsedString) + 1
                            )
                 )
                  -
                 (
                  Patindex(@CacheUsedSearchString, message) + Len(@CacheUsedString) + 1
                 )
                )
               ) As LookupBytesUsed
    , Convert(bigint, Substring(message,
                                (
                                 Patindex(@CacheUsedSearchString, message) + Len(@CacheUsedString) + 1 ),
                                (
                                 (
                                  Charindex(' ',
                                            message,
                                            Patindex(@CacheUsedSearchString, message) + Len(@CacheUsedString) + 1
                                           )
                                 )
                                  -
                                 (
                                  Patindex(@CacheUsedSearchString, message) + Len(@CacheUsedString) + 1
                                 )
                                )
                               )
             )
            /
             Convert(bigint,
                     Substring(message,
                               (
                                Patindex(@LookupStringBeginsWithSearchString, message) + Len(@LookupStringBeginsWith) + 1 ),
                                (
                                 (Charindex(' ',
                                            message,
                                            Patindex(@LookupStringBeginsWithSearchString, message) + Len(@LookupStringBeginsWith) + 1
                                           )
                                 )
                                -
                                 (
                                  Patindex(@LookupStringBeginsWithSearchString, message) + Len(@LookupStringBeginsWith) + 1
                                 )
                                )
                               )
                    ) As LookupBytesPerRow
    From catalog.operation_messages
    Where message_source_type = 60 -- Data Flow Task
      And message Like @LookupStringBeginsWithSearchString
      And operation_id = Coalesce(@operation_id, operation_id)

    While this is not production-ready code, you may be able to use it to glean insight into SSIS performance metrics and to learn more about SSIS Catalog internals.

    Enjoy!

    Learn more:
    Watch the Video
    Advanced SSIS Training with Tim Mitchell and Andy Leonard in Dallas, TX 9-11 Mar 2015
    Linchpin People Blog: SSIS
    Stairway to Integration Services
    Test your knowledge

    :{>

  • When Wronged…

    My lovely bride and I visited Paris last year for SQL Saturday 323. We stuck around a few days to do touristy stuff and we learned a lot about the history of France. While reading about an uprising in the late 1800’s, Christy stumbled upon the story of l'affaire Dreyfus (the Dreyfus Affair).

    In 1894 Captain Alfred Dreyfus was convicted of treason and sentenced to the Devil’s Island penal colony in French Guiana. It was later learned Dreyfus was innocent and another person was actually guilty of the crime for which Dreyfus was being punished. A trial was held against the other fellow but crucial evidence was suppressed and Dreyfus remained imprisoned for this crime he did not commit. After five years at Devil’s Island, Dreyfus received another trial and was again convicted. But he was subsequently pardoned and set free.

    The Dreyfus Affair is considered a textbook case of public opinion winning over justice and popular social bias – prejudice against Jews (Dreyfus was of Alsatian Jewish descent) – skewing principles of state.

    It took years, but Dreyfus was exonerated. In 1906, he returned to the French Army as a major. He was forced to resign in 1907, but served as a reserve officer during World War I.

    The Dreyfus Affair impacts France even today. I find many parts of this story fascinating. I was first (and most) struck by the fact that Dreyfus did not quit.  He was determined to survive Devil’s Island, which he documented in Five Years of My Life, 1894-1899. After pardon, he was not satisfied until he had been exonerated. And after that, he sought reinstatement back into the French Army.

    That’s the lesson I take from Col. Dreyfus today: When wronged, don’t quit.

    Are people wronged today? Does it happen in our field of database technology? Yep and yep. Has this happened to you? It’s happened to me. My advice: You may not be exonerated, at least not officially, but I encourage you to learn from your “affair.” You will likely learn lessons about yourself as some character traits – strengths and weaknesses – are only revealed when tested. Learn those things. And move forward in your newfound knowledge with strength.

    :{>

  • Getting Started with SSIS: Renaming Your First Package

    When you create an SSIS Project using SQL Server Data Tools – Business Intelligence (SSDT-BI), a new, empty SSIS package is added to the project. It is named “Package.dtsx.” One of the first things you want to do is rename this package, providing a more descriptive and more unique name. To rename the package, right-click the package name (Package.dtsx) in Solution Explorer and then click Rename.

    GSwS1stPkg_1

    Solution Explorer is a treeview control. Once you click Rename, the Package.dtsx node in the treeview switches into edit mode, allowing you to edit the name of the node. The name of the package – “Package” in this case – is selected, but not the extension (“dtsx”):

    GSwS1stPkg_2

    You can now type the new package name – I typed “StageTemperature”:

    GSwS1stPkg_3

    When you press the Enter key, the package is renamed:

    GSwS1stPkg_4

    It is possible to change the Name property of the SSIS package in the Properties Window. Do not change the Name property of the SSIS Package in the Properties Window.

    GSwS1stPkg_5

    Always rename the SSIS package in the Solution Explorer using the method described above.

    Congratulations! You just renamed an SSIS package!

    Learn more:
    Linchpin People Blog: SSIS
    Stairway to Integration Services
    Test your knowledge

  • Some Thoughts on Leadership

    The purpose of leading is not to be out front. Being out front is simply where good leaders find themselves. “Front” is merely a location, it conveys no authority. And it is possible to find oneself out front and not be a leader.

    The goal of a leader should not be to serve oneself, it should be to serve others. “Which others, Andy?” I’m glad you asked. Everyone who crosses your path. This is what is meant by the terms servant leadership. It comes from an idea found in the Bible where Jesus told his disciples leaders place others ahead of themselves and serve everyone.

    Who, Not Where, You Are

    Leaders serve others. By doing so, they inspire others. You can seek leaders by searching for titles but all you will find is holders of titles who may or may not be leaders. How do you identify leaders? Search for followers. People naturally follow leaders; titles are optional.

    But Leaders Are Out Front

    Leadership is not a location, it is not a position; leadership is a role. Yes, leaders are seen as “first” by others. Part of effective leadership is correcting the misperceptions that the leader is “better.” Leaders perform a role on the team or in the organization. Expressed hierarchically, leaders are on the same level as team members performing other roles. Part of the leader’s role is to interface with outsiders and coordinate team activities and facilitate individual activities of team members. These responsibilities are often (and easily) confused with being in charge and dictating the work of the team and telling each individual what to do, but that’s not the true nature of leadership.

    Leaders either lead or they do not. If a leader chooses to not lead that doesn’t make them a non-leader, it simply means they are not exercising their gift or performing their role.

    Born or Built?

    Are leaders born to lead or trained to lead? The short answer is “yes.” Leaders are born with some of the skills and talents of a leader. Leaders learn how to apply their skills and gain experience over time. Some leaders are born with more and some learn more, but all are born with some skill and learn from there. In either case, leadership grows.

    Desire?

    Some see the desire to lead as an automatic disqualifier for leadership – especially servant leadership. I disagree. I think desire is not necessarily an indication that one should be a leader. In and of itself, desire is not enough to make a leader effective. But certainly the inverse holds: if one is born with leadership skills and abilities and has learned more about leadership, it is natural for that person to desire to lead. After all, we all desire to be good at what we do; and if one is good at leadership it is to be expected that one will want to lead.

    Learn more:

    Managing Geeks 

    :{>

  • Getting Started with SSIS: SSDT-BI

    SNAG-0023

    SQL Server Data Tools – Business Intelligence (SSDT-BI) is a rich Integrated Development Environment (IDE). It is a version of Microsoft Visual Studio, and you can tell by looking at the title bar when you open SSDT-BI. Click on the image to enlarge and you will see “Microsoft Visual Studio” right there in the title bar.

    If the Start Page does not display, you can open it by clicking View—>Start Page. There are several useful links here. Once you begin developing SSIS projects, the list of Recent Projects will populate, providing a handy way to open the last thing you were working on. There are also links to help you get started developing using the Visual Studio Shell (Integrated) IDE.

    Let’s build an SSIS project!

     

    Click the New Project link on the Start Page to open the New Project window:

    SNAG-0025

    Click to enlarge the image and you will see several project templates listed beneath the Business Intelligence virtual folder. For SSIS development, select the template named “Integration Services Project”. In the Name textbox, type a name for your project: LoadStageDatabase. Note the solution is also named LoadStageDatabase. When you enter a name for your SSIS project, SSDT-BI automatically copies the Project name to the Solution name. You can decouple the Project and Solution names by typing in the Solution name textbox. Click the Ok button to create the SSIS project and solution:

    SNAG-0026

    Package.dtsx is created along with the project and solution. The Getting Started window also opened providing links to articles to help you get started developing SSIS packages. Feel free to click these links to learn more about SSIS development.

    Click the Save button to save your SSIS project.

    You’ve just created an SSIS project!

    Learn more:
    Watch the video!
    Linchpin People Blog: SSIS
    Stairway to Integration Services
    Test your knowledge

  • Testing

    It’s 2015 and we still have no flying cars. (Dear Doc Brown, we still need roads. Love, Andy) On a similar note, we’ve suffered through another year of software breaches and empty promises to fix the issues behind them. Brian Kelley (Blog | @kbriankelley) was right, We Don’t Care About Data and IT Security.

    Part of the issue is testing. Do you test for security?

    Estimation

    I am often asked, “Andy, how long will it take to test this solution?” My response is, “About as long as it takes to develop the solution.” Project managers love me. Well, not so much. It’s not their fault, the blame lies with unrealistic expectations and the response is usually along the lines of, “Will adding people to this project shorten the development cycle?” to which I respond, “I have nine women, can I get a baby in one month?”

    So what happens? The testing cycle is compressed from weeks or months into a few days or a week. And we wonder why there are security leaks? and why the software doesn’t perform?

    Results

    Please join me on this asymptote for a little hyperbole…

    If we flew airplanes like we manage software projects the plane would take off, fly to the destination at altitude, and nose-dive into the runway. From 30,000 feet to 0 feet in a straight line; straight down. The results of such a trip match what we see in software development.

    When people talk to me about software projects like Healthcare.gov, they act as though this is a fluke. It isn’t a fluke; this is how software is developed in the mid-20-teens. Stakeholders say they want quality, but what they mean when they say “quality” is that they want to hit a deadline. Please do not misunderstand me: deadlines are important for a host of legitimate and good and right reasons, but they are no good for software security and solutions testing.

    Developers vs. Estimation

    Stakeholders (rightly) question the estimates of developers because most developers stink at estimation. One of two things must be true, though:

    1. Developers are liars or idiots or pig-heads who will not or cannot or refuse to produce useful estimates; or
    2. The work is inestimable.

    The answer is 2.

    Solutions

    This is not an easy problem to solve. “Why is that, Andy?” I’m glad you asked. The definition of stupid is doing the same thing over and over again and expecting different results. Here are some things to change if you want different (or even better) outcomes to your software development projects:

    • Realistic expectations.  If software is inestimable, how much time should be spent trying to produce an estimate? Let’s see… doing the math here… carrying the one… I get precisely 0 hours. Stakeholders know what they want and – usually – when they want it. Start there, add what developers know, and walk away from this 15-minute meeting with the expectation that work will begin and you will meet again tomorrow to see how much work has been accomplished.
    • Authority. The developers have none, the stakeholders have it all. Scrum places responsibility for development in the hands of developers and equips them with the necessary authority to make decisions about the features that are implemented in each sprint. If developers lack the authority to remove features from the sprint, you are not practicing Scrum. Period.
    • Communication. Scrum supports daily communications between developers and stakeholders. Stakeholders are not allowed to speak during the 15-minute stand-up meetings. If stakeholders are talking, you are not practicing Scrum. If stakeholders are not in attendance, you are not practicing Scrum. (Do you sense a pattern here?)
    • Time. Testing and development take time. The biggest mistake in software estimation is planning for nothing to go wrong. Plan for everything to fail (at least once) and then succeed.
    • Money. If you believe software development and testing are expensive, you should see the price tag for a data breach. Enough said.

    Conclusion

    Evidence-based management provides vital feedback. Learn to apply EBS in your organization; it’s the most effective way to improve software estimation.

This Blog

Syndication

News

Friend of Red Gate

My Company


Blog Roll


Check out the Linchpin People Blog...
Linchpin People Blog

Contact Me

Archives

Powered by Community Server (Commercial Edition), by Telligent Systems
  Privacy Statement