Pesquisar este blog

Mostrando postagens com marcador Changeman. Mostrar todas as postagens
Mostrando postagens com marcador Changeman. Mostrar todas as postagens

segunda-feira, 6 de julho de 2020

Manuais Changeman - Controle de versao mainframe

Manuais Changeman - Controle de Versão Mainframe

Manuais Changeman - Controle de Versão Mainframe

Atualização em 11/06/2025:

Este post foi revisado hoje com a ajuda do Perplexity AI (e quem sabe mais alguma IA que eu nem conhecia até agora!).

Fiquei lembrando da Borland, que era simplesmente o máximo nos anos 90 para qualquer dev (Delphi, Turbo Pascal, C++ Builder, etc).

Se você curte história de tecnologia, vale a pena ler In Search of Stupidity: Over 20 Years of High-Tech Marketing Disasters, que explica como a Borland colapsou: basicamente, uma sequência de decisões de marketing ruins, briga de egos, aquisições malucas e a concorrência feroz da Microsoft.

Depois, a Micro Focus dominou com o Mainframe Express e, agora, apareceu até a Rocket Software com documentação nova do Changeman, que eu nunca tinha ouvido falar.

A propósito, segue um link novo e funcional da documentação Changeman (Rocket Software):

https://docs.rocketsoftware.com/pt-BR/bundle?cluster=true&labelkey=prod_changeman_zmf


Vamos ver o que a IA gerou... olha, não gostei não. Demora muito, cria narrativa que não tem fundamento, baseia-se em uma fonte e essa fonte você não acha. Não segue uma linha cronológica de acontecimentos, não pega os fatos que levaram de A a D, simplesmente ignora o B e o C. Sei lá, ainda não está bom a ponto de deixar seguir a vida sozinha, mas já está muito, muito melhor que o bom e velho Watson que tive meu primeiro contato lá pelos idos de 2014, se não me engano.

À época fiquei deveras impressionado. Não avançou muito nesses últimos 10 anos. A IBM é incomparável na arte de inovar/criar um negócio totalmente doido, disruptivo de verdade e não conseguir/saber vender. E aí, depois de uns 5-10 anos, aparece algum gatuno, 'rouba' a ideia e faz dinheiro com isso. Sempre foi assim, desde os primórdios! Eu gosto muito, respeito a Big Blue, já passei por lá em duas ocasiões, mas olha, dá dó!

Não lembro direito, mas no livro que citei no comecinho deve ter! Não tudo, porque daria um livro só de grandes big fails da IBM, mas um ou outro deve ter sim.

Enfim, bora colocar o que a IA gerou e seguir com a vida...


Atualização em 11/06/2025:

Este post foi revisado hoje com a ajuda do Perplexity AI — e, sinceramente, é incrível como as inteligências artificiais vêm transformando a forma de pesquisar, cruzar informações e atualizar conteúdos técnicos e históricos. Ferramentas como essa permitem que a gente conecte fatos, datas e curiosidades que antes exigiam horas de garimpo manual.

No meio dessa atualização, acabei embarcando numa viagem nostálgica ao lembrar da Borland — uma verdadeira lenda para quem viveu o auge do desenvolvimento de software nos anos 80 e 90. Para muitos devs, Borland era sinônimo de inovação e produtividade: nomes como Delphi, Turbo Pascal, C++ Builder e Paradox marcaram época e criaram padrões de facilidade e qualidade em programação. Não à toa, muita gente dizia que “quem usava Borland, programava sorrindo

Mas, como tantas gigantes da tecnologia, a Borland também teve seus dias difíceis. O livro In Search of Stupidity: Over 20 Years of High-Tech Marketing Disasters conta em detalhes como decisões de marketing desastrosas, brigas internas e a concorrência implacável da Microsoft acabaram levando a Borland do topo ao declínio. No mundo tech, não basta ter o melhor produto: estratégia, timing e humildade para ouvir o mercado são fundamentais.

Linha do tempo do ChangeMan ZMF:

  • Serena Software: O ChangeMan ZMF nasceu e foi desenvolvido pela Serena, tornando-se referência em controle de versão para mainframe.
  • Micro Focus: Em 2016, a Micro Focus comprou a Serena e passou a controlar o ChangeMan ZMF, além de já ser dona de ferramentas como o Mainframe Express (cuja origem remonta à Merant, outra fusão histórica do mundo COBOL).
  • OpenText: Em 2023, a OpenText adquiriu a Micro Focus, levando junto o portfólio de produtos mainframe e ALM.
  • Rocket Software:Em 2024, a Rocket Software comprou da OpenText toda a divisão de Application Modernization and Connectivity (AMC), incluindo o ChangeMan ZMF, RUMBA, Reflection, ferramentas COBOL e outros clássicos do universo mainframe.

Ou seja, o ChangeMan já passou pelas mãos de Serena, Micro Focus, OpenText e agora está sob o guarda-chuva da Rocket Software, que tem histórico forte em soluções para mainframe, integração, modernização e automação de ambientes z/OS.

O universo mainframe, que muitos consideram “antigo”, segue se reinventando. Ferramentas clássicas como o ChangeMan continuam evoluindo, mostrando que tradição e inovação podem andar juntas — e que o legado dessas empresas ainda faz diferença para quem trabalha com missão crítica.

Fica aqui o convite para quem quiser explorar mais: segue um link novo e funcional da documentação Changeman (Rocket Software), que pode ser uma mão na roda para quem está lidando com controle de versão em ambientes z/OS ou simplesmente quer matar a curiosidade sobre como essas ferramentas evoluíram.


Conteúdo original do post permanece abaixo, eram só essas 2 linhas aqui abaixo! uauauauaua

Acho que nem lembrava que a Borland, sic, Microfocus tinha comprado o changeman.

https://www.microfocus.com/documentation/changeman-zmf/changemanzmf813/

quinta-feira, 14 de fevereiro de 2019

REXX para localizar string em pacotes do Changeman

Atualizado em 2025 06 11 - Reescreve o post com ajuda do perplexity, nao testei o fonte e nem comparei pra ver se ele mudou alguma coisa, mas bonito devo dizer que ficou!


REXX para localizar string em pacotes do Changeman

Este script REXX realiza uma busca por uma string em todos os membros de um pacote do Changeman, gerando um relatório com os resultados encontrados. Útil para quem precisa localizar rapidamente trechos de código ou referências em ambientes mainframe integrados ao ChangeMan.

Exemplo de uso

Execute o script informando a sigla do sistema, o número do pacote e a string a ser pesquisada.

Código REXX

FINDCHG.REXX

/**  REXX  **/                                                        
arg sigla pacote texto                                                
call valida_parametros;                                                
call verifica_se_pacote_existe;                                        
/* aqui a magica acontece! */                                          
call outtrap "mbrs."                                                  
"LISTD" "'"pdsname"'" "MEMBERS"                                        
call outtrap "off"                                                    
                                                                       
do ndx=1 to mbrs.0                                                    
   if mbrs.ndx = "--MEMBERS--" then leave                              
end                                                                    
ndx=ndx+1                                                              
qtd_membros = mbrs.0 - ndx + 1                                        
say 'Procuraremos a string em ' qtd_membros ' membros.'                
/* "ALLOC FI(RELAT) DA('WALBUGA.OUTDD.SAIDA') MOD REUSE" */            
log = USERID()'.OUTDD.SAIDA'                                          
say log                                                                
/* "ALLOC FI(RELAT) DA(log) MOD REUSE"                                
   "ALLOC F(SYS010) DS('"particionado"("membro")') SHR REUSE"          
   "ALLOC FI(RELAT) DA('WALBUGA.OUTDD.SAIDA') MOD REUSE"  */          
 "ALLOC FI(RELAT) DA('"log"') MOD REUSE"                              
IF RC \= 0 THEN                                                        
   DO                                                                  
      say "----------------------------------------"                  
      say "Erro na alocacao do arquivo de relatorio"                  
      say "----------------------------------------"                  
     EXIT 0                                                            
   END                                                                
/* aqui a magica acontece 2! */                                        
call listdsi "'"pdsname"'"                                            
particionado=sysdsname                                                
/**-----------------------------------------------------------------**/
linha.1="------------------------------------------------"            
linha.2="Inicio do processamento ------------------------"            
linha.3="------------------------------------------------"              
linha.4="Procurando " pdsname " por <" texto ">"                        
linha.5="------------------------------------------------"              
linha.0=5                                                              
"EXECIO" linha.0 "DISKW RELAT (STEM linha."                            
do curmbr = ndx to mbrs.0                                              
   parse value mbrs.curmbr with membro                                  
   membro=strip(membro)                                                
   flag=1                                                              
/* say "member="particionado"("membro")" */                            
/* assim sai o membro */                                                
/* aqui =  'particionadome' ||(membro) */                              
/* aqui = "'"(membro)"'" */                                            
/* say aqui */                                                          
/* "ALLOC F(SYS010) DS('"particionado"("membro")') SHR REUSE" */        
   "ALLOC F(SYS010) DS('"particionado"("membro")') SHR REUSE"          
/* "ALLOC F(SYS010) DS("'"aqui"'") SHR REUSE" */                        
   "EXECIO * DISKR SYS010 (FINIS STEM in."                              
   "FREE F(SYS010)"                                                    
   fnd=0                                                                
   do recid=1 to in.0                                                  
      if pos(texto,in.recid) > 0 then                                  
        do                                                              
           if flag = 1 then                                            
             do                                                        
              linha.1="------------------------------------------------"
              linha.2="----> " membro " contem <" texto ">"            
              say linha.2                                              
              linha.3 = in.recid                                        
              linha.0=3                                                
              "EXECIO" linha.0 "DISKW RELAT (STEM linha."              
              flag=0                                                    
             end                                                        
           linha.1 = in.recid                                          
           linha.0=1                                                    
           "EXECIO" linha.0 "DISKW RELAT (STEM linha."                  
        end                                                            
   end                                                                  
end                                                                    
say '*** Pesquisa finalizada com sucesso ***'                          
linha.1="////////////////////////////////////////////////"            
linha.2="////////////////////////////////////////////////"            
linha.3="////////////////////////////////////////////    "            
linha.4="//////////////////////////////////////////// FIM"            
linha.5="////////////////////////////////////////////////"            
linha.0=5                                                              
"EXECIO" linha.0 "DISKW RELAT (STEM linha."                            
"EXECIO 0 DISKW RELAT (FINIS"                                          
"FREE F(RELAT)"                                                        
exit 0                                                                
                                                                       
/*----------------------- */                                          
valida_parametros:                                                    
/*----------------------- */                                          
if sigla = "" | pacote = "" | texto = "" then                          
 do                                                                    
   clear                                                              
   say ""                                                              
   say "Bem vindo "  USERID()                                          
   say ""                                                              
   say  "Informe: "                                                    
   say  " - sigla do sistema"                                          
   say  " - numero do pacote "                                        
   say  " - string a ser pesquisada"                                  
   say ""                                                              
   say  "Como não foi informado abrirei a opcao de informar abaixo."  
   say ""                                                              
   say  "Digite SAI para sair, tecle ENTER para continuar..."          
   pull ok                                                            
   say ""                                                              
   /* if parse upper (ok) = 'SAI' then         -- VER USO DO UPPER */  
   if ok = 'SAI' then                                                  
    do                                                                
      exit 0                                                          
    end                                                                
 end                                                                  
if sigla = "" then                                                    
   do                                                                  
      say "----------------------------------------------------"      
      say "Erro: Informe a sigla do sistema com duas posicoes"        
      say "----------------------------------------------------"      
      say ""                                                          
      say 'Digite a sigla:'                                            
      pull sigla                                                      
   end                                                                
if pacote = "" then                                                    
   do                                                                  
      say "--------------------------------"                          
      say "Erro: Não foi informado o pacote"                          
      say "--------------------------------"                          
      say ""                                                          
      say "Procuraremos em DESICBIB.CHGMAN.STG.NG0I.#pacote.SRC"      
      say ""                                                          
      say 'Digite o numero do pacote com 6 numeros :'                  
      pull pacote                                                      
   end                                                                
if texto = "" then                                                    
   do                                                                  
      say "-----------------------------------------------------------"
      say "Erro: Não foi informada a string a ser pesquisada no pacote"
      say "-----------------------------------------------------------"
      say ""                                                          
      say 'Digite a string:'                                          
      pull texto                                                      
   end                                                                
return                                                                
                                                                       
                                                                       
/*------------------------------------- */                            
verifica_se_pacote_existe:                                            
/*------------------------------------- */                            
                                                                       
/*         DESICBIB.CHGMAN.STG.NG0I.#000651.SRC */                    
pdsname = 'DESICBIB.CHGMAN.STG.'sigla'0I.#'pacote'.SRC'                
    say '---------------------------------------------------------------'
    say 'Procurando' texto ' em 'pdsname''                                
    say '---------------------------------------------------------------'
    x = SYSDSN("'"pdsname"'")      /* só pros feras!!! ODEIO ISSO */      
    say x ', vamos em frente que o pacote ta lá!'                        
    say '---------------------------------------------------------------'
    if x <> "OK" then                                                    
       do                                                                
          say "Erro: Não conseguimos localizar o pacote #" pacote        
          say "Erro: Não conseguimos localizar o pacote:" pdsname        
          say "Error: " pdsname " > " sysdsn(pdsname)                    
          say "Press Enter to continue"                                  
          pull uresp                                                      
          exit 8                                                          
       end                                                                
    return                                            

Como funciona

  • Valida os parâmetros de entrada (sigla, pacote, texto).
  • Verifica se o pacote existe no Changeman.
  • Lista todos os membros do pacote e busca a string informada em cada um.
  • Gera um relatório de saída com os membros e linhas onde a string foi encontrada.

Observações

  • O script pode ser adaptado para outros padrões de pacotes ou ambientes.
  • Certifique-se de ter as permissões necessárias para executar comandos de alocação e leitura de membros no ambiente mainframe.