Rubrica InterSystems FAQ

No SQL, dados NULL e a string vazia ('') são dados diferentes. O método para definir e checar cada uma é como se segue

(1) dado NULL

[SQL] 

insertintotest(a) values(NULL)
select * fromtestwhere a ISNULL

[InterSystems ObjectScript]

setx=##class(User.test).%New()
setx.a=""

(2) String Vazia ('')

[SQL]

insertintotest(a) values('')
select * fromtestwhere a = ''

[InterSystems ObjectScript]

setx=##class(User.test).%New()
setx.a=$C(0)

Para mais informações, por favor veja os seguintes documentos:

NULL e strings vazias [IRIS]
NULL e strings vazias

Como estou desenvolvendo uma aplicação para auditoria de arquivo fiscal digital, EFD ICMS IPI, optei por armazenar os dados diretamente em globais. Uma vez que os registros do arquivo EFD são formato txt e tem características semelhantes às linhas de registro de global.

Para poder analisar os itens de saída das Notas Fiscais Eletrônicas, fiz a importação também dos dados destes arquivos, e os armazenei em global. Segue exemplo:

[FAQ] Preguntas frecuentes de InterSystems

O seguinte código baixa https://www.intersystems.com/assets/intersystems-logo.png e salva o arquivo como c:\temp\test.png.

É necessário definir uma configuração SSL chamada SSLTEST antes de executar esse código

Rubrica InterSystems FAQ

Isso pode ser conseguido usando o procedimento CSV() da classe %SQL.Util.Procedures .
Abaixo está o exemplo de uso do código. (Assumindo que o arquivo test.csv está em c:\temp.)

Olá!

Recentemente estive investigando uma situação incômoda enquanto editava classes ou rotinas ObjectScript no VSCode. O que acontecia era que, como estava escrevendo as linhas de código na minha classe (por exemplo: a adição de um novo método, mudança da assinatura de classe ou de um bloco de código) isso ocasionava uma rápida revisão da sintaxe, reformatação e compilação - e inevitavelmente (já que eu estava apenas na metade da escrita), isso gerava erros de compilação.

O Visual Studio Code lança novas atualizações todo mês com novos recursos e correções de bugs, e a versão de junho de 2024 já está disponível.

A Versão 1.91 inclui: 

Olá Comunidade

Nesse artigo, vou introduzir minha aplicação irisChatGPT construída no LangChain Framework.

Primeiramente, vamos ter uma breve visão geral desse framework.
O mundo inteiro está falando sobre o ChatGPT e como as Large Language Models (LLMs - Grandes modelos de linguagem) se tornaram tão poderosas e tem performado além das expectativas, oferecendo conversas quase humanas. Isso é só o começo de como isso pode ser aplicado em qualquer empresa e qualquer domínio!

Olá a todos! 

Trabalho há muitos anos com Excel e, ultimamente, foquei no tratamento de bases de dados.

Realmente minha experiencia com Excel foi para trabalhos financeiros, não tanto analíticos de dados em si, mas em um projeto recente pude trabalhar muito com SQL e me interessei um pouco pelo tema (não sou nenhuma uma especialista, já aviso!)

Me perguntei como poderia unir vários excels em um para, por exemplo, entregá-lo à Análise de dados utilizando a tecnologia InterSystems. Juntei toda a informação em um pequeno artigo. Espero que seja útil e, é claro, estou aberta a correções.

Traduzido do Concurso de Artigos da Comunidade Espanhola 

Seguindo o último concurso de programação no OEX (Open EXchange) eu tive algumas observações surpreendentes.
Havia aplicações quase exclusivas baseadas numa combinação de IA (Inteligência Artificial) com módulos Python "pré-cozidas".
Porém, indo mais a fundo, todos os exemplos usaram os mesmos fatores técnicos do IRIS.

Considerando o ponto de vista do IRIS, foi praticamente a mesma coisa seja buscando por textos, ou imagens, ou outro tipo de padrão. Acabou em métodos quase intercambiáveis.

Há 2 anos eu venho utilizando Python embutido diariamente. Talvez seja o momento de compartilhar um feedback sobre essa jornada.

Por que escrever esse feedback? Porque eu acredito que sou como a maioria das pessoas aqui, um desenvolvedor ObjectScript, e penso que a comunidade poderia ter algum benefício desse feedback e entender melhor os prós e contras de escolher Python embutido para desenvolver em IRIS. Além de evitar algumas armadilhas.

• Feedback : Usando Python embutido diariamente por 2 anos
• Introdução
• Começando com Python
  • Python não é ObjectScript
    • Pep8
    • Modulos
    • Dunders
  • Conclusão
• Python Embutido
  • O que é Python embutido?
  • Como usar Python embutido?
  • Como eu uso Python embutido
    • Use libraries e códigos Python como se fossem classes ObjectScript
      • Com a tag de linguagem
      • Sem a tag de lingaugem
      • Conclusão
    • Use uma primeira abordagem Python
      • Exemplo: iris-fhir-python-strategy
      • Observações
      • Onde achar o código
        • Como implementar uma estratégia
        • Implementação de InteractionsStrategy
        • Implementação de interações
        • Interações em Python
        • Implementação da classe abstrata de Python
      • Muito longo, faça um resumo

Introdução

Eu sou desenvolvedor desde 2010 e trabalho com ObjectScript desde 2013.

Então são aproximadamente 10 anos de experiência com ObjectScript.

Desde 2021 e o lançamento do Python Embutido no IRIS, eu me propus um desafio:

• Aprender Python
• Fazer tudo o máximo possível com Python

Quando eu comecei essa jornada, eu não tinha ideia do que era Python. Então, comecei com o básico e ainda estou aprendendo todo dia.

Começando com Python

O lado bom do Python é que é fácil de aprender. É ainda mais fácil se você já conhece ObjectScript.

Por quê? Elas têm muito em comum.

Então, se você conhece ObjectScript você já sabe muito sobre Python.

Porém, há algumas diferenças, dentre as quais algumas não são fáceis de entender.

Python não é ObjectScript

Para manter as coisas simples, vou focar nas principais diferenças entre ObjectScript e Python.

Para mim, há 3 principais diferenças:

• Pep8
• Módulos
• Dunders

Pep8

O que é Pep8 ?

É um conjunto de regras para escrever códigos Python.

pep8.org

Algumas delas são:

• Convenção de nomenclatura
• nomes de variáveis
  • snake_case
• nomes de classes
  • CamelCase
• indentação
• comprimento da linha
• etc.

Por que isso é importante?

Porque é a maneira de escrever código Python. Se você não seguir essas regras, terá dificuldade em ler o código de outras pessoas e elas terão dificuldade de ler o seu.

Como desenvolvedores ObjectScript, também temos algumas regras para seguir, mas não são tão rígidas como a Pep8.

Eu aprendi Pep8 da maneira mais difícil.

Para contar a história, eu sou engenheiro de vendas na InterSystems e estou fazendo várias demos. Certo dia, eu estava fazendo uma demo de Python Embutido para um cliente que era desenvolvedor Python, e a conversa encurtou quando ele viu meu código. Ele me contou que meu código não era nada "Pythonico" (ele estava certo). Eu estava programando em Python como eu programava em ObjectScript. Por causa disso, ele disse que não estava interessado no Python Embutido mais. Eu fiquei chocado e decidi aprender Python do jeito certo.

Assim, se você quer aprender Python, aprenda Pep8 primeiro.

Módulos

Os módulos são uma funcionalidade que não temos em ObjectScript.

Geralmente, em linguagens orientadas a objetos, há classes e pacotes. No Python, temos classes, pacotes e módulos.

O que é um módulo?

É um arquivo com extensão .py. É a maneira de organizar seu código.

Você não entendeu? No começo eu também não. Portanto vamos usar um exemplo.

Geralmente, quando você quer criar uma classe em ObjectScript, você cria um arquivo .cls e coloca sua classe ali dentro. E, se quiser criar outra classe, usa outro arquivo .cls. Por fim, se quiser criar um pacote, você gera uma pasta e coloca os arquivos .cls dentro dela.

Em Python fazemos o mesmo, mas ele tem a habilidade de guardar várias classes num mesmo arquivo. Esse arquivo é chamado módulo. É importante saber que é "Pythônico" ter muitas classes em um mesmo arquivo.

Portanto, planeje de antemão como pretende organizar seu código e como vai nomear seus módulos para não terminar como eu, com um monte de módulos com o mesmo nome das suas classes.

Um mau exemplo:

A bad example :

MinhaClasse.py

class MinhaClasse:
    def __init__(self):
        pass

    def meu_metodo(self):
        pass

Para instanciar essa classe, você fará:

import MinhaClasse.MinhaClasse # estranho, né?

minha_classe= MinhaClasse()

Estranho, né?

Dunders

Dunders são métodos especiais em Python. Eles são chamados de dunder porque começam e terminam com dois caracteres underscores (_).

Eles são similares aos métodos do ObjectScript com '%'.

Eles são usados para:

• construtor
• sobrecarga de operador
• representação do objeto
• etc.

Exemplo:

class MinhaClasse:
    def __init__(self):
        pass

    def __repr__(self):
        return "MyClass"

    def __add__(self, other):
        return self + other

Aqui temos 3 métodos dunder:

• __init__ : construtor
• __repr__ : representação do objeto
• __add__ : sobrecarga de operador

Métodos Dunders estão por toda parte em Python. São uma grande parte da linguagem, mas não se preocupe; você vai aprendê-los rapidamente,

Conclusão

Python não é ObjectScript, e você terá que aprender. Mas não é tão difícil, então você vai aprender rápido. Apenas mantenha em mente que você deverá aprender Pep8 e como organizar seu código com módulos e métodos dunder.

Bons sites para aprender Python

• geeksforgeeks.org
• w3schools.com
• realpython.com

Python Embutido

Agora que você conhece um pouco mais sobre o Python, vamos falar de Python Embutido.

O que é o Python Embutido?

Python Embutido é uma maneira de executar código Python dentro do IRIS. É uma nova funcionalidade do IRIS 2021.2+. Isso significa que seu código Python será executado no mesmo processo que o IRIS.

No mais, toda classe ObjectScript é uma classe Python, e o mesmo cale para métodos e atributos, e vice-versa. 🥳 Isso é bacana!

Como usar Python Embutido?

Há 3 maneiras diferentes de usar Python Embutido:

• Usando a tag de linguagem do ObjectScript
  • Method Foo() As %String [ Language = python ]
• Usando a função ##class(%SYS.Python).Import()
• Usando o interpretador de Python
  • python3 -c "import iris; print(iris.system.Version.GetVersion())"

Mas se você quiser usar mesmo o Python Embutido, você terá que evitar usar a tag de linguagem.

Por quê?

• Porque não é Pythônico
• Porque também não é ObjectScript
• Porque você não terá um debugador
• Porque você não terá um linter
• Porque você não terá um formatador
• Porque você não terá um framework de testes
• Porque você não terá um gerenciador de pacotes
• Porque você está misturando duas linguagens no mesmo arquivo
• Porque quando o seu processo quebra, você não tem um rastreio da pilha
• Porque você não pode usar um ambiente virtual ou ambientes conda
• ...

Não me entenda mal, isso funciona e pode ser útil se você quiser testar algo rapidamente, mas na minha opinião não é uma boa prática.

Então, o que eu aprendi nesses 2 anos de Python Embutido, e como utilizá-lo da maneira correta?

Como eu uso Python embutido

Para mim, existem duas opções:

• Usar libraries do Python como se fossem classes do ObjectScript
  • with ##class(%SYS.Python).Import() function
• Usar uma abordagem de Python em primeiro lugar.

Usar libraries do Python como se fossem classes do ObjectScript

Você ainda quer usar Python no seu código ObjectScript, mas não quer usar a tag de linguagem. O que você pode fazer, então?

"Simplesmente" usar códigos e libraries do Python como se fossem classes ObjectScript.

Vamos tomar como exemplo:

Você quer usar a library requests (é uma library para fazer requisições HTTP) no seu código ObjectScript

Com a tag de linguagem

ClassMethod Get() As %Status [ Language = python ]
{
	import requests

	url = "https://httpbin.org/get"
	# faça uma requisição get
	response = requests.get(url)
	# pegue os dados do json de resposta
	data = response.json()
	# iterar pelos dados e printar os pares chave-valoe
	for key, value in data.items():
		print(key, ":", value)
}

Por que eu não acho uma boa ideia?

Porque você está misturando duas linguagens no mesmo arquivo, e você não tem um debugador, um linter, um formatador, etc. Se esse código der algum problema, você terá dificuldade de debugar. Se você não tem um rastreio da pilha, não saberá da onde veio o erro. E também não tem a funcionalidade de completar automaticamente.

Sem a tag de linguagem

ClassMethod Get() As %Status
{
	set status = $$$OK
    set url = "https://httpbin.org/get"
    // Importar o módulo Python "requests" como uma classe ObjectScript 
    set request = ##class(%SYS.Python).Import("requests")
    // Chamar o método get da classe request
    set response = request.get(url)
    // Chamar o método json da classe response
	set data = response.json()
    // Aqui os dados são um dicionário Python
    // Para iterar por um dicionário Python, você deve usar o método dunder e items().
	// Importar um módulo pré-existente de Python.
	set builtins = ##class(%SYS.Python).Import("builtins")
    // Aqui estamos usando "len" do módulo de pré-existentes (built in) para saber o comprimento do dicionário.
    For i = 0:1:builtins.len(data)-1 {
        // Agora nós convertemos os itens do dicionário para uma lista, então pegamos a chave e o valor usando o método dunder __getitem__
		Write builtins.list(data.items())."__getitem__"(i)."__getitem__"(0),": ",builtins.list(data.items())."__getitem__"(i)."__getitem__"(1),!
	}
	quit status
}

Por que eu acho isso uma boa ideia?

Porque você está utilizando Python como se fosse ObejctScript. Você está importando a library requests como uma classe ObjectScript e usando como se fosse uma classe ObjectScript. Toda a lógica está em ObjectScript, e você utiliza o Python como uma library. Até para manutenção, é mais fácil de ler e entender; qualquer desenvolvedor ObjectScript consegue entender esse código. A desvantagem é que você tem que saber como usar os métodos dunders, e como usar Python como se fosse ObjectScript.

Conclusão

Acredite em mim, dessa maneira você vai acabar com um código mais robusto e conseguirá debugar facilmente. A princípio parece difícil, mas você vai entender os benefícios de aprender Python mais rápido do que você pensa.

Usar uma abordagem de Python em primeiro lugar

Essa é a maneira que eu prefiro usar Python Embutido

Eu construí várias ferramentas usando essa abordagem e estou muito feliz com isso.

Alguns exemplos:

• iop
• iris-python-interoperability-template
• iris-imap-adapter
• iris-chemicals-properties
• rest-to-dicom
• iris-fhir-python-strategy

Então, o que é uma abordagem de Python em primeiro lugar?

Existe apenas uma regra: o código Python deve estar em arquivos . py, o código ObjectScript deve estar em arquivos .cls

Como conseguir isso?

A ideia é criar classes de invólucro de ObjectScript para chamar o código Python.

Vamos tomar o exemplo de iris-fhir-python-strategy :

Exemplo : iris-fhir-python-strategy

Primeiramente, nós temos que entender como o servidor IRIS FHIR funciona.

Todo servidor IRIS FHIR implementa uma Strategy (estratégia).

Uma Strategy é um conjunto de duas classes:

As duas classes são do tipo Abstract (abstratas).

• HS.FHIRServer.API.InteractionsStrategy é uma classe Abstractque deve ser implementada para customizar o comportamento do Servidor FHIR.
• HS.FHIRServer.API.RepoManager é uma classe Abstract que deve ser implementada para customizar o armazenamento do servidor FHIR.

Observações

Para o nosso exemplo, vamos focar apenas na classe HS.FHIRServer.API.InteractionsStrategy, mesmo que a classe HS.FHIRServer.API.RepoManager também seja implementada e obrigatória para customizar o Servidor FHIR. A classe HS.FHIRServer.API.RepoManager é implementada pela classe HS.FHIRServer.Storage.Json.RepoManager, que é a implementação padrão do Servidor FHIR.

##Onde achar o código

Todo o código fonte pode ser achado nesse repositório: iris-fhir-python-strategy A pasta src contém as seguintes pastas:

• python : contém o código Python
• cls : contem o código ObjectScript que é usado para chamar o código Python

Como implementar uma Strategy

Nesta prova de conceito, só estaremos interessados em como implementar uma Strategy em Python, não em como implementar um RepoManager (gerenciador de repositório).

Para implementar uma Strategy você deve criar pelo menos duas classes:

• Uma classe que herda da HS.FHIRServer.API.InteractionsStrategy
• Uma classe que herda da HS.FHIRServer.API.Interactions class

Implementação de InteractionsStrategy

A classe HS.FHIRServer.API.InteractionsStrategy foca em customizar o comportamento do Servidor FHIR ao sobrescrever os seguintes métodos:

• GetMetadataResource: chamado para pegar os metadados do servidor FHIR
  • esse é o único método que vamos sobrescrever nessa prova de conceito

HS.FHIRServer.API.InteractionsStrategy também tem dois parâmetros:

• StrategyKey : um identificador único para a InteractionsStrategy
• InteractionsClass : o nome da subclasse de Interactions

Implementação de Interactions

A classe HS.FHIRServer.API.Interactions foca em customizar o comportamento do Servidor FHIR ao sobrescrever os seguintes métodos:

• OnBeforeRequest : chamada antes da requisição ser enviada ao servidor
• OnAfterRequest : chamada após a requisição ser enviada ao servidor
• PostProcessRead : chamada após a operação de leitura estar finalizada
• PostProcessSearch : chamada após a operação de procura estar finalizada
• Read : chamada para ler um recurso
• Add : chamada para adicionar um recurso
• Update : chamada para atualizar um recurso
• Delete : chamada para deletar um recurso
• e muito mais...

Nós implementamos a classe HS.FHIRServer.API.Interactions no arquivo src/cls/FHIR/Python/Interactions.cls.

Class FHIR.Python.Interactions Extends (HS.FHIRServer.Storage.Json.Interactions, FHIR.Python.Helper)
{
Parameter OAuth2TokenHandlerClass As%String = "FHIR.Python.OAuth2Token";
Method %OnNew(pStrategy As HS.FHIRServer.Storage.Json.InteractionsStrategy) As%Status
{
// %OnNew é chamado quando o objeto é criado.// O parâmetro pStrategy é o objeto de estratégia criado nesse objeto.// A implementação padrão não faz nada// Primeiro define o caminho do Python de uma variável de ambienteset..PythonPath = $system.Util.GetEnviron("INTERACTION_PATH")
// Depois define o nome da classe de Python pela variável de ambienteset..PythonClassname = $system.Util.GetEnviron("INTERACTION_CLASS")
// Então define o nome do módulo Python pela variável de ambienteset..PythonModule = $system.Util.GetEnviron("INTERACTION_MODULE")
<span class="hljs-keyword">if</span> (<span class="hljs-built_in">..PythonPath</span> = <span class="hljs-string">""</span>) || (<span class="hljs-built_in">..PythonClassname</span> = <span class="hljs-string">""</span>) || (<span class="hljs-built_in">..PythonModule</span> = <span class="hljs-string">""</span>) {
	<span class="hljs-comment">//quit ##super(pStrategy)</span>
	<span class="hljs-keyword">set</span> <span class="hljs-built_in">..PythonPath</span> = <span class="hljs-string">"/irisdev/app/src/python/"</span>
	<span class="hljs-keyword">set</span> <span class="hljs-built_in">..PythonClassname</span> = <span class="hljs-string">"CustomInteraction"</span>
	<span class="hljs-keyword">set</span> <span class="hljs-built_in">..PythonModule</span> = <span class="hljs-string">"custom"</span>
}


<span class="hljs-comment">// Então, define a classe Python</span>
<span class="hljs-keyword">do</span> <span class="hljs-built_in">..SetPythonPath</span>(<span class="hljs-built_in">..PythonPath</span>)
<span class="hljs-keyword">set</span> <span class="hljs-built_in">..PythonClass</span> = <span class="hljs-keyword">##class</span>(FHIR.Python.Interactions).GetPythonInstance(<span class="hljs-built_in">..PythonModule</span>, <span class="hljs-built_in">..PythonClassname</span>)

<span class="hljs-keyword">quit</span> <span class="hljs-keyword">##super</span>(pStrategy)
}
Method OnBeforeRequest(
pFHIRService As HS.FHIRServer.API.Service,
pFHIRRequest As HS.FHIRServer.API.Data.Request,
pTimeout As%Integer)
{
// OnBeforeRequest é chamado antes de cada requisição ser processada.if$ISOBJECT(..PythonClass) {
set body = ##class(%SYS.Python).None()
if pFHIRRequest.Json '= "" {
set jsonLib = ##class(%SYS.Python).Import("json")
set body = jsonLib.loads(pFHIRRequest.Json.%ToJSON())
}
do..PythonClass."on_before_request"(pFHIRService, pFHIRRequest, body, pTimeout)
}
}
Method OnAfterRequest(
pFHIRService As HS.FHIRServer.API.Service,
pFHIRRequest As HS.FHIRServer.API.Data.Request,
pFHIRResponse As HS.FHIRServer.API.Data.Response)
{
// OnAfterRequest é chamado depois de cada requisição ser processada.if$ISOBJECT(..PythonClass) {
set body = ##class(%SYS.Python).None()
if pFHIRResponse.Json '= "" {
set jsonLib = ##class(%SYS.Python).Import("json")
set body = jsonLib.loads(pFHIRResponse.Json.%ToJSON())
}
do..PythonClass."on_after_request"(pFHIRService, pFHIRRequest, pFHIRResponse, body)
}
}
Method PostProcessRead(pResourceObject As%DynamicObject) As%Boolean
{
// PostProcessRead é chamada após um recurso ser lido na base de dados.// Retorna 1 para indicar que o recurso deve ser incluído na resposta.// Retorna 0 para indicar que o recurso deve ser excluído da resposta.if$ISOBJECT(..PythonClass) {
if pResourceObject '= "" {
set jsonLib = ##class(%SYS.Python).Import("json")
set body = jsonLib.loads(pResourceObject.%ToJSON())
}
return..PythonClass."post_process_read"(body)
}
quit1
}
Method PostProcessSearch(
pRS As HS.FHIRServer.Util.SearchResult,
pResourceType As%String) As%Status
{
// PostProcessSearch é chamado depois de uma busca.// Retorna $$$OK para indicar que a busca teve sucesso.// Retorna um código de erro para indicar que a busca falhou.if$ISOBJECT(..PythonClass) {
return..PythonClass."post_process_search"(pRS, pResourceType)
}
quit$$$OK
}
Method Read(
pResourceType As%String,
pResourceId As%String,
pVersionId As%String = "") As%DynamicObject
{
return##super(pResourceType, pResourceId, pVersionId)
}
Method Add(
pResourceObj As%DynamicObject,
pResourceIdToAssign As%String = "",
pHttpMethod = "POST") As%String
{
return##super(pResourceObj, pResourceIdToAssign, pHttpMethod)
}
/// Returns VersionId for the "deleted" version
Method Delete(
pResourceType As%String,
pResourceId As%String) As%String
{
return##super(pResourceType, pResourceId)
}
Method Update(pResourceObj As%DynamicObject) As%String
{
return##super(pResourceObj)
}
}

A classeFHIR.Python.Interactions herda das classes HS.FHIRServer.Storage.Json.Interactions e FHIR.Python.Helper.

A classe HS.FHIRServer.Storage.Json.Interactions é o padrão de implementação do Servidor FHIR.

A classe FHIR.Python.Helper foca em ajudar chamar o código Python pelo ObjectScript .

A classe FHIR.Python.Interactions sobrescreve os métodos a seguir:

• %OnNew : chamado quando o objeto é criado
  • nós usamos esse método para definir o caminho, nome da classe de, e nome de módulo do Python a partir das variáveis de ambiente.
  • se as variáveis de ambiente não forem definidas, utilizamos valores padrão.
  • também definimos a classe python
  • chamamos o método %OnNew da classe pai.

Method %OnNew(pStrategy As HS.FHIRServer.Storage.Json.InteractionsStrategy) As %Status
{
	// Primeiro, definimos o caminho Python por uma variável de ambiente
	set ..PythonPath = $system.Util.GetEnviron("INTERACTION_PATH")
	// Então, definimos o nome da classe Python pela variável de ambiente
	set ..PythonClassname = $system.Util.GetEnviron("INTERACTION_CLASS")
	// Depois, definimos o nome do módulo Python da variável de ambiente
	set ..PythonModule = $system.Util.GetEnviron("INTERACTION_MODULE")

	if (..PythonPath = "") || (..PythonClassname = "") || (..PythonModule = "") {
		// usa valores padrão
		set ..PythonPath = "/irisdev/app/src/python/"
		set ..PythonClassname = "CustomInteraction"
		set ..PythonModule = "custom"
	}

	// A seguir, definimos a classe Python
	do ..SetPythonPath(..PythonPath)
	set ..PythonClass = ..GetPythonInstance(..PythonModule, ..PythonClassname)

	quit ##super(pStrategy)
}

• OnBeforeRequest : chamada antes da requisição ser enviada ao servidor
  • chamamos o método on_before_request da classe Python
  • passamos os objetos HS.FHIRServer.API.Service e HS.FHIRServer.API.Data.Request , o corpo da requisição e o tempo limite de execução.

Method OnBeforeRequest(
	pFHIRService As HS.FHIRServer.API.Service,
	pFHIRRequest As HS.FHIRServer.API.Data.Request,
	pTimeout As %Integer)
{
	// OnBeforeRequest é chamado antes de cada requisição ser processada.
	if $ISOBJECT(..PythonClass) {
		set body = ##class(%SYS.Python).None()
		if pFHIRRequest.Json '= "" {
			set jsonLib = ##class(%SYS.Python).Import("json")
			set body = jsonLib.loads(pFHIRRequest.Json.%ToJSON())
		}
		do ..PythonClass."on_before_request"(pFHIRService, pFHIRRequest, body, pTimeout)
	}
}

• OnAfterRequest : chamado após a requisição ser enviada ao servidor
  • chamamos o método on_after_request da classe Python
  • passamos os objetos HS.FHIRServer.API.Service, HS.FHIRServer.API.Data.Request e HS.FHIRServer.API.Data.Response e o corpo da resposta

Method OnAfterRequest(
	pFHIRService As HS.FHIRServer.API.Service,
	pFHIRRequest As HS.FHIRServer.API.Data.Request,
	pFHIRResponse As HS.FHIRServer.API.Data.Response)
{
	// OnAfterRequest é chamado após cada requisição ser processada
	if $ISOBJECT(..PythonClass) {
		set body = ##class(%SYS.Python).None()
		if pFHIRResponse.Json '= "" {
			set jsonLib = ##class(%SYS.Python).Import("json")
			set body = jsonLib.loads(pFHIRResponse.Json.%ToJSON())
		}
		do ..PythonClass."on_after_request"(pFHIRService, pFHIRRequest, pFHIRResponse, body)
	}
}

• E por aí em diante...

Interactions em Python

A classe FHIR.Python.Interactions chama os métodos on_before_request, on_after_request, ... da classe Python.

Aqui está uma classe Python abstrata:

import abc
import iris

class Interaction(object):
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def on_before_request(self, 
                          fhir_service:'iris.HS.FHIRServer.API.Service',
                          fhir_request:'iris.HS.FHIRServer.API.Data.Request',
                          body:dict,
                          timeout:int):
        """
        on_before_request é chamada depois que a requisição é enviada ao servidor.
        param fhir_service: o objeto de serviço fhir iris.HS.FHIRServer.API.Service
        param fhir_request: o objeto de requisição fhir iris.FHIRServer.API.Data.Request
        param timeout: o tempo limite de execução em segundos
        return: None
        """
        

    @abc.abstractmethod
    def on_after_request(self,
                         fhir_service:'iris.HS.FHIRServer.API.Service',
                         fhir_request:'iris.HS.FHIRServer.API.Data.Request',
                         fhir_response:'iris.HS.FHIRServer.API.Data.Response',
                         body:dict):
        """
        on_after_request é chamada após a requisição ser enviada ao servidor.
        param fhir_service: o objeto de serviço fhir iris.HS.FHIRServer.API.Service
        param fhir_request: o objeto de requisição fhir iris.FHIRServer.API.Data.Request
        param fhir_response: o objeto de resposta fhir iris.FHIRServer.API.Data.Response
        return: None
        """
        

    @abc.abstractmethod
    def post_process_read(self,
                          fhir_object:dict) -> bool:
        """
        post_process_read é chamado após a operação de leitura finalizar.
        param fhir_object: o objeto fhir
        return: True - o recurso deve ser  retornado ao cliente, False - caso contrário
        """
        

    @abc.abstractmethod
    def post_process_search(self,
                            rs:'iris.HS.FHIRServer.Util.SearchResult',
                            resource_type:str):
        """
        post_process_search é chamada após a operação de pesquisa finalizar.
        param rs: o resultado da pesquisa iris.HS.FHIRServer.Util.SearchResult
        param resource_type: o tipo de recurso
        return: None
        """

Implementação da classe Python abstrata

from FhirInteraction import Interaction

class CustomInteraction(Interaction):

    def on_before_request(self, fhir_service, fhir_request, body, timeout):
        # Extrai o usuário e seus papéis para essa requisição
        # então o consentimento pode avaliado.
        self.requesting_user = fhir_request.Username
        self.requesting_roles = fhir_request.Roles

    def on_after_request(self, fhir_service, fhir_request, fhir_response, body):
        # Limpa o usuário e seus papéis entre as requisições.
        self.requesting_user = ""
        self.requesting_roles = ""

    def post_process_read(self, fhir_object):
        # Avalia consentimento baseado no recurso e usuários/papéis
        # Retornar 0 indica que esse recurso não deveria ser exibido - um erro  "404 Not Found" (não encontrado)
        # Será retornado ao usuário.
        return self.consent(fhir_object['resourceType'],
                        self.requesting_user,
                        self.requesting_roles)

    def post_process_search(self, rs, resource_type):
        # Itera por cada recurso no conjunto de pesquisa e avalia
        # Consentimento baseado no recurso e usuário/papéis
        # Cada linha marcada como deletada e salva será excluída do Bundle (conjunto ad resposta).
        rs._SetIterator(0)
        while rs._Next():
            if not self.consent(rs.ResourceType,
                            self.requesting_user,
                            self.requesting_roles):
                # Marca a linha como deletada e salva.
                rs.MarkAsDeleted()
                rs._SaveRow()

    def consent(self, resource_type, user, roles):
        # Exemplo de lógica de consentimento - só permite que usuários com o papel '%All' vejam
        # Recursos de observações.
        if resource_type == 'Observation':
            if '%All' in roles:
                return True
            else:
                return False
        else:
            return True

Muito longo, faça um resumo

A classe FHIR.Python.Interactions é um invólucro para chamar a classe Python.

As classes abstratas IRSI são implementadas para envolver as classes abstratas Python 🥳.

Isso nos ajuda a manter o código Python e o código ObjectScript separados e então se beneficiar do melhor dos dois mundos.

Olá, Desenvolvedores!

Suponha que você tenha uma classe persistente com dados e queira ter uma IU Angular simples para visualizar os dados e fazer operações CRUD.

Recentemente, @Alberto Fuentes descreveu como desenvolver uma IU Angular para seu aplicativo do InterSystems IRIS usando RESTForms2. 

Neste artigo, quero explicar a você como obter uma IU Angular simples para fazer operações CRUD e visualizar seus dados de classes do InterSystems IRIS automaticamente em menos de 5 minutos.

Vamos lá!

Para isso, você precisará do seguinte:

• 1. InterSystems IRIS
• 2. ZPM
• 3. Módulos RESTForms2 e RESTForms2-UI.

Usarei uma classe Data.Countries, que gerei e importei pelo csvgen usando este comando:

d ##class(community.csvgen).GenerateFromURL("https://raw.githubusercontent.com/datasciencedojo/datasets/master/WorldDBTables/CountryTable.csv",",","Data.Countries"

Para criar uma IU Angular, precisamos expor a API REST para essa classe, que servirá as operações CRUD.

Vamos usar o módulo restforms2 para isso. 

Esse comando no dockerfile instala restforms2 no contêiner IRIS:

zpm "install restforms2" \

Para adicionar uma API REST, precisamos derivar a classe de Form.Adaptor:

Class Data.Countries Extends (%Library.Persistent, Form.Adaptor)

Adicione os parâmetros restforms2 à classe persistente para gerenciar o comportamento geral: parâmetro de classificação, nome de exibição etc.:

// Nome do formulário, e não uma chave global, então pode ser qualquer coisa
Parameter FORMNAME = "Countries";
/// Permissões padrão
/// Objetos desse formulário podem ser Criados, Lidos, Atualizados e Excluídos
/// Redefina esse parâmetro para mudar as permissões para todo mundo
/// Redefina o método checkPermission (veja Form.Security) para essa classe 
/// para adicionar a segurança personalizada com base em usuário/funções/etc.
Parameter OBJPERMISSIONS As %String = "CRUD";
/// Propriedade usada para informações básicas sobre o objeto
/// Por padrão, o método getObjectDisplayName recebe seu valor dela
Parameter DISPLAYPROPERTY As %String = "name";

Perfeito. Em seguida, podemos usar a sintaxe restforms2 para informar ao restforms2 quais propriedades queremos expor às operações CRUD. Você pode fazer isso adicionando o atributo "DISPLAYNAME =" às propriedades que você quer expor em restforms2-ui. Exemplo:

Property code As %Library.String(MAXLEN = 250) [ SqlColumnNumber = 2 ];
Property name As %Library.String(DISPLAYNAME = "Name", MAXLEN = 250) [ SqlColumnNumber = 3 ];
Property continent As %Library.String(DISPLAYNAME = "Continent", MAXLEN = 250) [ SqlColumnNumber = 4 ];
Property region As %Library.String(DISPLAYNAME = "Region", MAXLEN = 250) [ SqlColumnNumber = 5 ];
Property surfacearea As %Library.Integer(DISPLAYNAME = "Surface Area", MAXVAL = 2147483647, MINVAL = -2147483648) [ SqlColumnNumber = 6, SqlFieldName = surface_area ];
Property independenceyear As %Library.Integer(DISPLAYNAME = "Independence Year", MAXVAL = 2147483647, MINVAL = -2147483648) [ SqlColumnNumber = 7, SqlFieldName = independence_year ];

Ótimo! Agora vamos introduzir a camada de UI.  Esse comando no dockerfile instala restforms2-ui, que é a IU Angular para Restform2:

zpm "install restforms2-ui" \

É isso! Vamos examinar a IU para sua classe, que você pode encontrar no URL server:port/restforms2-ui:

RESTForms são usados com as classes de teste Person e Company, e você pode usar isso para examinar os recursos de restformsUI. No momento, é possível editar campos de string, número, booleano, data e consulta.

Você pode testar tudo isso no seu laptop, se clonar e compilar este repositório:

docker-compose up -d --build

E abrir o URL:

localhost:port/restforms2-ui/index.html

ou, se você usar o VSCode, selecione esse item do menu:

Boa programação e fique ligado!

Introdução

Nas próximas semanas, meus colegas de trabalho estão planejando começar a usar VSCode para programar com os produtos InterSystems. Entre as várias vantagens disso, eu gostaria de salientar a possibilidade de se conectar com outras tecnologias, como o GitHub, com facilidade. Além disso, o VSCode também oferece uma extensa loja de extensões, onde você pode achar vários recursos adicionais gratuitos que fazem a programação mais rápida e eficiente. Por último e não menos importante, para conquistar os corações de todo desenvolvedor, é Open Source.

Olá a todos!

Estou com o seguinte problema

Em uma rotina chamei o método da seguinte forma:

;
;
;
write !, "Informe uma palavra ou frase para verificar: "
;
read str
;
set sc = $$ValidarPalindromo^YYHORG001(str)
;
;
write !, sc
;
quit

Método da classe YYHORG001

Preciso fazer  o seguinte exercício:

"Crie uma regra/método que solicite 10 números ao usuário e no final apresente-os em tela, ordenados do menor para o maior."

Porém já li e reli a documentação, e não consigo entender como criar regra/método no Caché.

Eu crio conforme a doc, mas não executa nada quando chamo a rotina no terminal.

Alguém pode me ajudar por favor?

Tentei function, procedure e subroutine também.

Recentemente, percebi que já faz muito tempo que não falo sobre os recursos mais recentes da extensão ObjectScript da InterSystems para Visual Studio Code.

Tenho o prazer de anunciar a versão 2.12.1 da extensão ObjectScript, contendo diversas melhorias que facilitam a vida do desenvolvedor. Alguns destaques são descritos abaixo, incluindo o recurso nº 1 solicitado pelo Global Summit – importação de XML!

Como sempre, encontre a lista completa de modificações no CHANGELOG, incluindo muitas correções de bugs e vulnerabilidades.

Interface do usuário mais limpa 

Talvez você não perceba isso, mas sua conta de login da InterSystems pode ser usada para acessar uma ampla variedade de serviços da InterSystems que ajudam você a aprender e usar o InterSystems IRIS e outras tecnologias da InterSystems de maneira mais eficaz.  Continue lendo para saber mais sobre como descobrir novos conhecimentos técnicos e ferramentas usando sua conta de login da InterSystems.  Além disso, após a leitura, participe da Enquete na parte inferior, para que possamos ver como este artigo foi útil para você!

O que é uma conta de login da InterSystems? 

Uma conta de login da InterSystems é usada para acessar diversos serviços online que atendem a parceiros e clientes atuais e em potencial.  É um conjunto único de credenciais usadas em mais de 15 aplicativos voltados ao público externo.  Alguns aplicativos (como a WRC ou o iService) exigem uma ativação específica para o acesso ser concedido pela conta.  Provavelmente, há recursos disponíveis que ajudarão você, mas você não os conhece: leia sobre todas as opções e teste uma nova ferramenta para melhorar sua técnica!!

Catálogo de aplicativos

Você pode ver todos os serviços disponíveis para você com sua conta de login da InterSystems ao acessar esse catálogo de aplicativos da InterSystems, localizado em:  https://Login.InterSystems.com.  Isso só listará os aplicativos ou serviços a que você tem acesso no momento.  Ele lembra seus aplicativos usados com mais frequência e os lista na parte superior para sua conveniência. 

Não se esqueça de marcar a página como favorita para acessar facilmente todas essas ferramentas na caixa de ferramentas da sua conta de login da InterSystems!

Detalhes dos aplicativos 

Agora, é hora de entrar nos detalhes de cada aplicativo e ver como eles podem ajudar você como desenvolvedor que trabalha com as tecnologias da InterSystems!  Continue lendo e tente encontrar um novo aplicativo que você possa usar pela primeira vez para melhorar sua eficiência e habilidades como desenvolvedor....

 Getting Started - gettingstarted.intersystems.com 

Público

• Qualquer pessoa que deseja explorar usando a plataforma de dados da InterSystems IRIS®

Descrição

• Aprenda a criar aplicativos de missão crítica e uso intensivo de dados rapidamente com o InterSystems IRIS.
• Siga vídeos e tutoriais que usam SQL, Java, C#/.Net, Node.js, Python ou InterSystems ObjectScript.
• Use um Sandbox gratuito, baseado na nuvem e dentro do navegador -- IRIS+IDE+Web Terminal— para seguir tutoriais. 

Como isso ajuda a melhorar sua técnica

• Familiarize-se rapidamente com a tecnologia da InterSystems e a veja em ação com código e exemplos reais!
• Explore o uso de outras linguagens de programação populares com o InterSystems IRIS.

 Online Learning - learning.intersystems.com

Público

• Todos os usuários atuais e em potencial dos produtos da InterSystems 

Descrição

• Materiais autoguiados para ajudar você a desenvolver e dar suporte aos aplicativos mais importantes do mundo:
  • Exercícios práticos
  • Vídeos
  • Cursos online
  • Programas de aprendizado

Como isso ajuda a melhorar sua técnica

• Aprenda, aprenda, aprenda!! 
• Nada ajudará você a se tornar um desenvolvedor eficiente mais rápido do que seguir um instrutor técnico habilidoso ensinando novos conceitos para usar nos seus projetos do InterSystems IRIS! 

 Documentação - docs.intersystems.com 

Público

• Todos os usuários atuais e em potencial dos produtos da InterSystems

Descrição

• Documentação para todas as versões dos nossos produtos
• Links, quando necessário, para documentação externa
• Todo o conteúdo recente é fornecido pelo nosso mecanismo de pesquisa.
• A página de pesquisa deixa você filtrar por produto, versão e outros aspectos.
• Algumas documentações exigem autorização (pela conta de login da InterSystems):
  • Documentação da AtScale disponível para clientes da Análise Adaptativa
  • Documentação da HealthShare disponível para usuários da HealthShare
• Use a nova Lista de Verificação de Impacto de Atualização dinâmica no servidor de documentação!

Como isso ajuda a melhorar sua técnica

• Use rapidamente materiais de referência de classes e documentação de APIs.
• Encontre amostras de código. 
• Leia documentação detalhada sobre o uso de partes do InterSystems IRIS em que você precisa se aprofundar.
• Solicite mais detalhes ou denuncie problemas diretamente nas páginas de documentação através do recurso "Feedback".

 Evaluation - evaluation.intersystems.com

Público

• Quem deseja baixar software ou licenças da InterSystems para uso em avaliação ou desenvolvimento

Descrição

• Downloads do InterSystems IRIS e InterSystems IRIS for Health.
• Qualquer pessoa pode baixar os kits do Community Edition.
• Os clientes atuais também podem solicitar uma licença avançada para avaliar os recursos corporativos.
• As versões de prévia estão disponíveis em pré-lançamento.
• Os pacotes do Programa de Acesso Antecipado permitem que as pessoas enviem feedback sobre produtos e recursos futuros.

Como isso ajuda a melhorar sua técnica

• Teste versões de prévia de software para ver como os novos recursos podem ajudar a acelerar seu desenvolvimento.
• Teste recursos corporativos ao solicitar uma licença de avaliação.
• Confira se todos os desenvolvedores na sua organização têm a versão mais recente do InterSystems IRIS instalada nas máquinas.
• Forneça feedback para a Gestão de Produtos da InterSystems sobre os Recursos do Acesso Antecipado para garantir que eles atendam às necessidades da sua equipe após o lançamento completo.

 Developer Community - community.intersystems.com

Público

• Qualquer pessoa que trabalha com a tecnologia do InterSystems (clientes atuais e em potencial, funcionários e parceiros da InterSystems)

Descrição

• Monitore comunicados relacionados aos produtos e serviços da InterSystems.
• Encontre artigos sobre uma variedade de tópicos técnicos.
• Faça perguntas e receba respostas da comunidade.
• Explore vagas de trabalho ou desenvolvedores disponíveis para contratação.
• Participe de competições com prêmios em dinheiro de US$ 1000.
• Fique por dentro de tudo relacionado a InterSystems!

Como isso ajuda a melhorar sua técnica

• Com o acesso aos principais especialistas do mundo em tecnologia da InterSystems, você pode aprender com os melhores e continuar interagindo com perguntas, tendências e tópicos em alta.
• Receba atualizações automaticamente na sua caixa de entrada sobre novos produtos, lançamentos e oportunidades do Programa de Acesso Antecipado.
• Obtenha ajuda de colegas para tirar suas dúvidas e superar obstáculos.
• Tenha discussões enriquecedoras com Gerentes e Desenvolvedores de Produtos da InterSystems: aprenda direto da fonte!
• Eleve suas habilidades a um novo patamar ao compartilhar soluções técnicas e código, além de receber feedback de outros.

 Ideias da InterSystems - ideas.intersystems.com

Público

• Quem deseja compartilhar ideias para melhorar a tecnologia da InterSystems.

Descrição

• Publique ideais sobre como melhorar a tecnologia da InterSystems.
• Leia avaliações existentes e vote ou participe em discussões.
• A InterSystems levará em conta as ideias mais populares para o desenvolvimento de produtos futuros.

Como isso ajuda a melhorar sua técnica

• Veja suas ideias e necessidades virarem realidade em produtos da InterSystems ou bibliotecas de código aberto.
• Familiarize-com ideias de colegas e aprenda a usar os produtos da InterSystems de novas maneiras.
• Implemente ideias sugeridas por outros, explorando novas partes da tecnologia da InterSystems.

 Global Masters - globalmasters.intersystems.com

Público

• Quem quer apoiar a tecnologia da InterSystems e ganhar emblemas e brindes

Descrição

• A plataforma de gamificação criada para que os desenvolvedores aprendam, fiquem por dentro e ganhem reconhecimento pelas contribuições através de conteúdo interativo.
• Os usuários recebem pontos e emblemas pelo seguinte:
  • Engajamento no Developer Community
  • Engajamento no Open Exchange
  • Publicação de posts nas redes sociais sobre produtos e tecnologias InterSystems
• Troque pontos por brindes ou treinamento gratuito da InterSystems

Como isso ajuda a melhorar sua técnica

• Os desafios chamam sua atenção para artigos ou vídeos que talvez não tenha visto no Developer Community, site Learning ou canal do YouTube, sempre aprendendo coisas novas para aplicar aos seus projetos!

 Open Exchange - openexchange.intersystems.com 

Público

• Desenvolvedores que buscam publicar ou usar ferramentas e pacotes de software reutilizáveis

Descrição

• Ferramentas e pacotes de desenvolvedores criados com as plataformas de dados e os produtos da InterSystems. 
• Os pacotes são publicados sob uma variedade de licenças de software (em grande parte, de código aberto).
• Integração com o GitHub para versionamento de pacotes, discussões e rastreamento de bugs
• Leia e envie avaliações e encontre os pacotes mais populares.
• Os desenvolvedores podem enviar issues e fazer melhorias nos pacotes por solicitações pull do GitHub para ajudar a avançar o software da comunidade.
• Os desenvolvedores podem ver estatísticas de tráfego e downloads de pacotes que publicaram

Como isso ajuda a melhorar sua técnica

• Não reinvente a roda!  Use pacotes de código aberto criados e mantidos pela InterSystems Community para resolver problemas genéricos, deixando que você foque no desenvolvimento de soluções específicas de que sua empresa precisa.
• A contribuição com os pacotes de código aberto é uma ótima maneira de receber feedback construtivo no seu trabalho e aprimorar seus padrões de desenvolvimento.
• Ser um contribuidor respeitado em projetos de código aberto é uma forma excelente de aumentar a demanda pelas suas habilidades e insights. 

 WRC - wrc.intersystems.com

Público

• Sistema de monitoramento para todos os problemas relatados por clientes no InterSystems IRIS e InterSystems HealthShare.  Os clientes com SUTA podem trabalhar diretamente com o aplicativo.

Descrição

• Aplicativo Central de Suporte (ou "WRC Direct").
• sistema de monitoramento para todos os problemas relatados por clientes. 
• Abra novas solicitações. 
• Veja todas as ações investigativas e adicione informações e comentários sobre uma solicitação. 
• Veja informações estatísticas sobre seu histórico de chamadas de suporte. 
• Encerre solicitações e ofereça feedback sobre o processo de suporte. 
• Revise arquivos de patches ad-hoc. 
• Monitore pedidos de alterações de software.
• Baixe versões de software de produto e cliente atuais.

Como isso ajuda a melhorar sua técnica

• Os Engenheiros de Suporte da InterSystems podem ajudar você a enfrentar obstáculos técnicos em relação ao desenvolvimento ou gerenciamento de sistemas com os produtos da InterSystems.
• Relate bugs para garantir que os problemas sejam corrigidos em versões futuras.  

 iService - iservice.intersystems.com

Público

• Clientes que precisam de suporte sob um contrato SLA

Descrição

• Uma plataforma de tíquetes de suporte para nossos clientes da saúde, na nuvem e hospedados.
• Permite cálculos e relatórios de compliance com o acordo de nível de serviço (SLA) orientado por regras.
• Oferece recursos avançados de exportação e pesquisa de aspectos. 
• Incorpora um sistema de gestão de Segurança Clínica completo.

Como isso ajuda a melhorar sua técnica

• Os Engenheiros de Suporte da InterSystems podem ajudar você a enfrentar obstáculos técnicos em relação ao desenvolvimento ou gerenciamento de sistemas com os produtos da InterSystems da saúde ou na nuvem.
• Relate bugs para garantir que os problemas sejam corrigidos em versões futuras.  

 ICR - containers.intersystems.com

Público

• Qualquer pessoa que queira usar contêineres da InterSystems

Descrição

• InterSystems Container Registry
• Um registro de contêineres acessível programaticamente e IU da Web para navegação.
• Contêineres do Community Edition disponíveis para todos.
• Versões comerciais do InterSystems IRIS e InterSystems IRIS for Health disponíveis para clientes atendidos.
• Gere tokens para usar nos pipelines CICD para buscar contêineres automaticamente.

Como isso ajuda a melhorar sua técnica

• Aumente a maturidade do seu SDLC ao migrar para pipelines CICD baseados em contêineres para desenvolvimento, testes e implantação!

 Diretório de Parceiros - partner.intersystems.com 

Público

• Quem quer encontrar um parceiro ou o produto de um parceiro da InterSystems 
• Parceiros que buscam anunciar software e serviços  

Descrição

• Pesquise todos os tipos de parceiros da InterSystems:
  • Parceiros de implementação
  • Parceiros de soluções
  • Parceiros de tecnologia
  • Parceiros da nuvem
• Os parceiros existentes podem gerenciar seus anúncios de serviços e software. 

Como isso ajuda a melhorar sua técnica

• Contrate especialistas certificados para aprender com eles nos seus projetos.
• Licencie soluções corporativas baseadas na tecnologia da InterSystems para não precisar desenvolver tudo do zero.
• Leve seus produtos e serviços para um público mais amplo, melhorando a procura e exigindo uma maior capacidade de entrega!

 CCR - ccr.intersystems.com 

Público

• Organizações selecionadas que gerenciam as alterações feitas em uma implementação da InterSystems (funcionários, parceiros e usuários finais)

Descrição

• Change Control Record
  • Aplicativo de fluxo de trabalho personalizado integrado na sua própria tecnologia para monitorar todas as personalizações dos produtos de saúde da InterSystems instalados no mundo todo.
• Versionamento e implantação de código personalizado no local e alterações na configuração.
• Vários níveis e opções de configuração de fluxo de trabalho.
• Bastante adaptável para atender às necessidades específicas da fase do projeto

Como isso ajuda a melhorar sua técnica

• Para equipes com o uso autorizado, encontre e reutilize código ou planos de implementação na sua organização, evitando precisar resolver o mesmo problema várias vezes.
• Resolva problemas na produção com muito mais rapidez, deixando mais tempo para o trabalho de desenvolvimento. 

 Client Connection - client.intersystems.com  

Público

• Disponível para qualquer cliente do TrakCare

Descrição

• InterSystems Client Connection é uma plataforma de colaboração e compartilhamento de conhecimento para clientes do TrakCare.
• Comunidade online para clientes do TrakCare desenvolvem conexões melhores e mais próximas.
• Em Client Connection, você encontrará o seguinte: 
  • Notícias e eventos do TrakCare 
  • Materiais de lançamentos do TrakCare, por exemplo, documentação de versões e vídeos de prévia
  • Acesso a guias de produtos atualizados.
  • Materiais de suporte para desenvolver o conhecimento pessoal.
  • Fóruns de discussão para aproveitar o conhecimento de colegas. 

Como isso ajuda a melhorar sua técnica

• Os especialistas técnicos e de aplicativos nos sites do TrakCare podem compartilhar perguntas e conhecimentos rapidamente, se conectando com outros usuários do mundo todo.  Com respostas mais rápidas, sobra mais tempo para desenvolver soluções!

 Pedidos online - store.intersystems.com

Público

• Usuários de operações em parceiros/usuários finais de aplicativos selecionados

Descrição

• Permita que os clientes escolham diferentes produtos de acordo com seus contratos e façam novos pedidos.  
• Permita que os clientes atualizem/troquem pedidos existentes.
• Envie pedidos às Operações de Clientes da InterSystems para processá-los para entrega e faturamento.
• Permita que os clientes migrem as licenças existentes para o InterSystems IRIS.

Como isso ajuda a melhorar sua técnica

• Honestamente, não ajuda!  É uma ferramenta usada pela equipe de operações, e não usuários técnicos, mas está incluída aqui para ficar completo, já que o acesso é controlado por uma conta de login da InterSystems ;)  

Outras coisas que você deve saber sobre sua conta de login da InterSystems

Aqui estão mais alguns fatos úteis sobre as contas de login da InterSystems...

Como criar uma conta de login

Os usuários podem criar sua própria conta ao clicar em "Create Account" em qualquer aplicativo da InterSystems voltado ao público, incluindo:

• https://evaluation.intersystems.com
• https://community.intersystems.com
• https://learning.intersystems.com

Como alternativa, o FRC (First Response Center) da InterSystems criará uma conta de login para clientes atendidos pela primeira vez que precisarem acessar a Central de Suporte (WRC) ou o iService (os clientes atendidos também podem criar contas para os colegas).

Antes de usar a conta, o usuário precisa aceitar os Termos e Condições, durante o processo de autoinscrição ou no primeiro login.

Opções alternativas de login

Alguns aplicativos permitem o login com o Google ou GitHub:

• Developer Community
• Open Exchange
• Global Masters

É a mesma conta de login da InterSystems, mas com a autenticação pelo Google ou GitHub.

Perfil da conta

Se você for até https://Login.InterSystems.com e fizer a autenticação, poderá acessar Opções > Profile e fazer alterações básicas na sua conta.  O e-mail pode ser alterado em Options > Change Email.  

Como resolver problemas da conta de login

Os problemas das contas de login da InterSystems devem ser encaminhados para Support@InterSystems.com.  Inclua o seguinte:

• Nome de usuário utilizado na tentativa de login
• E-mail
• Tipo e versão do navegador
• Mensagens e/ou capturas de tela do erro específico
• Data e hora do erro recebido   

Sejam todos bem-vindos!

Neste breve artigo, quero apresentar um exemplo de uso que vários de vocês que trabalham com o IRIS como back-end para seus web applications devem ter enfrentado mais de uma vez: como enviar um arquivo do front-end para o servidor.

Em geral, a maneira mais simples que encontrei de realizar essa tarefa é transformar o arquivo do front-end para o formato Base64 e fazer uma chamada POST para o servidor anexando o Base64 obtido a uma mensagem JSON onde é indicado o nome do arquivo em um parâmetro e os dados codificados em outro. Algo parecido com isto:

{
    "fileData": "JVBERi0xLjQKJdPr6eEKMSAwIG...",
    "fileName": "example.pdf"
}

Da minha instância IRIS, configurei um web application para gerenciar essas chamadas POST de uma classe que estende %CSP.REST. Essa classe tem um classmethod para gerenciar o POST corretamente. O código deve ficar assim:

ClassMethod SaveFile() As%Status
{
    Try {
        Do##class(%REST.Impl).%SetContentType("application/json")
        If '##class(%REST.Impl).%CheckAccepts("application/json") Do##class(%REST.Impl).%ReportRESTError(..#HTTP406NOTACCEPTABLE,$$$ERROR($$$RESTBadAccepts)) Quit// Lendo o corpo da chamada http com os dados do arquivo
    <span class="hljs-keyword">set</span> dynamicBody = {}.<span class="hljs-built_in">%FromJSON</span>(<span class="hljs-built_in">%request.Content</span>)

    <span class="hljs-keyword">set</span> dynamicStream = dynamicBody.<span class="hljs-built_in">%Get</span>(<span class="hljs-string">"fileData"</span>,,<span class="hljs-string">"stream&lt;base64"</span>)
    
    <span class="hljs-keyword">set</span> stream=<span class="hljs-keyword">##class</span>(<span class="hljs-built_in">%Stream.FileBinary</span>).<span class="hljs-built_in">%New</span>()
    <span class="hljs-keyword">set</span> sc=stream.LinkToFile(<span class="hljs-string">"/shared/durable/"</span>_dynamicBody.fileName)
    <span class="hljs-keyword">set</span> sc=stream.CopyFromAndSave(dynamicStream)
   
} <span class="hljs-keyword">Catch</span> (ex) {
    <span class="hljs-keyword">Do</span> <span class="hljs-keyword">##class</span>(<span class="hljs-built_in">%REST.Impl</span>).<span class="hljs-built_in">%SetStatusCode</span>(<span class="hljs-string">"400"</span>)
    <span class="hljs-keyword">Do</span> <span class="hljs-keyword">##class</span>(<span class="hljs-built_in">%REST.Impl</span>).<span class="hljs-built_in">%WriteResponse</span>(ex.DisplayString())
    <span class="hljs-keyword">return</span> {<span class="hljs-string">"errormessage"</span>: <span class="hljs-string">"Client error"</span>}
}
<span class="hljs-keyword">Quit</span> <span class="hljs-built_in">$$$OK</span>
}

Vamos explicar em detalhes o que esse método está fazendo:

1. Recebemos o conteúdo enviado no corpo da mensagem e transformamos isso em um %Library.DynamicAbstractObject que pode ser lido como um objeto.

   set dynamicBody = {}.%FromJSON(%request.Content)

    

2. Essa etapa é onde a mágica acontece. Transformamos nosso Base64 em um tipo %Stream que podemos obter usando o método %Get da classe %Library.DynamicObject.

3. set dynamicStream = dynamicBody.%Get("fileData",,"stream<base64")

   Como você pode ver, estamos passando como um parâmetro de entrada o tipo de transformação que queremos realizar, em nosso exemplo de Base64 para Stream (stream<base64). Qual é a vantagem de usar essa instrução? Bem, não vamos estar limitados pelo valor MAXSTRING, ou seja, se nosso arquivo em Base64 for muito grande, nunca vamos receber uma exceção porque ultrapassamos o limite máximo de comprimento permitido para uma String.
4. Por fim, criamos em nosso servidor o arquivo que conterá os dados enviados em Base64 com o nome definido na chamada recebida e escrevemos nosso objeto de tipo %Stream nele.

   set stream=##class(%Stream.FileBinary).%New()
   set sc=stream.LinkToFile("/shared/durable/"_dynamicBody.fileName)
   set sc=stream.CopyFromAndSave(dynamicStream)

Como você pode ver, é muito fácil gerenciar arquivos em Base64 do nosso servidor. Se você tiver dúvidas, não hesite em escrevê-las na seção de comentários. Será um prazer responder.

Temos um delicioso conjunto de dados com receitas escritas por vários usuários do Reddit, porém, a maioria das informações é texto livre, como o título ou a descrição de um post. Vamos descobrir como carregar o conjunto de dados facilmente, extrair algumas características e analisá-las usando recursos do modelo de linguagem grande da OpenAI no Embedded Python e no framework Langchain.

Carregando o conjunto de dados

Primeiro de tudo, precisamos carregar o conjunto de dados ou podemos só nos conectar a ele?

Há diferentes maneiras de alcançar isso: por exemplo, é possível usar o CSV Record Mapper em uma produção de interoperabilidade ou até em aplicativos legais do OpenExchange, como csvgen.

Vamos usar o Foreign Tables. Um recurso bastante útil para projetar dados armazenados fisicamente em outro lugar no IRIS SQL. Podemos usar isso para ter uma primeira visão dos arquivos do conjunto de dados.

Criamos um Foreign Server:

CREATE FOREIGN SERVER dataset FOREIGN DATA WRAPPER CSV HOST '/app/data/'

E, em seguida, uma Foreign Table que se conecta ao arquivo CSV:

CREATE FOREIGN TABLE dataset.Recipes (
  CREATEDDATE DATE,
  NUMCOMMENTS INTEGER,
  TITLE VARCHAR,
  USERNAME VARCHAR,
  COMMENT VARCHAR,
  NUMCHAR INTEGER
) SERVER dataset FILE 'Recipes.csv' USING
{
  "from": {
    "file": {
       "skip": 1
    }
  }
}

É isso, imediatamente podemos executar consultas SQL em "dataset.Recipes":

## Quais dados são necessários? O conjunto de dados é interessante e estamos com fome. No entanto, se quisermos decidir uma receita para cozinhar, será preciso mais algumas informações que possamos usar para análise.

Vamos trabalhar com duas classes persistentes (tabelas):

• yummy.data.Recipe: uma classe que contém o título e a descrição da receita e algumas outras propriedades que queremos extrair e analisar, por exemplo, Score, Difficulty, Ingredients, CuisineType, PreparationTime (nota, dificuldade, ingredientes, tipo de culinária, tempo de preparo)
• yummy.data.RecipeHistory: uma classe simples para registrar o que estamos fazendo com a receita

Podemos agora carregar nossas tabelas "yummy.data*" com o conteúdo do conjunto de dados:

do ##class(yummy.Utils).LoadDataset()

Parece bom, mas ainda precisamos descobrir como vamos gerar os dados para os campos Score, Difficulty, Ingredients, PreparationTime e CuisineType.

## Analise as receitas Queremos processar cada título e descrição de receita e:

• Extrair informações como Difficulty, Ingredients, CuisineType etc.
• Criar nossa própria nota com base em nossos critérios para que possamos decidir o que queremos cozinhar.

Vamos usar o seguinte:

• yummy.analysis.Analysis - uma estrutura de análise genérica que podemos reutilizar para desenvolver mais análises.
• yummy.analysis.SimpleOpenAI - uma análise que usar o Embedded Python + framework Langchain + modelo LLM da OpenAI.

LLM (modelos de linguagem grande) são realmente uma ótima ferramenta para processar linguagem natural.

LangChain está pronto para uso no Python, então podemos usá-lo diretamente no InterSystems IRIS usando o Embedded Python.

A classe "SimpleOpenAI" completa fica assim:

/// Análise simples da OpenAI para receitas
Class yummy.analysis.SimpleOpenAI Extends Analysis
{

Property CuisineType As %String;

Property PreparationTime As %Integer;

Property Difficulty As %String;

Property Ingredients As %String;

/// Execute
/// Você pode tentar isto a partir de um terminal:
/// set a = ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(8))
/// do a.Run()
/// zwrite a
Method Run()
{
    try {
        do ..RunPythonAnalysis()

        set reasons = ""

        // meus tipos de culinária favoritos
        if "spanish,french,portuguese,italian,korean,japanese"[..CuisineType {
            set ..Score = ..Score + 2
            set reasons = reasons_$lb("It seems to be a "_..CuisineType_" recipe!")
        }

        // não quero passar o dia todo cozinhando :)
        if (+..PreparationTime < 120) {
            set ..Score = ..Score + 1
            set reasons = reasons_$lb("You don't need too much time to prepare it") 
        }
        
        // bônus para ingredientes favoritos!
        set favIngredients = $listbuild("kimchi", "truffle", "squid")
        for i=1:1:$listlength(favIngredients) {
            set favIngred = $listget(favIngredients, i)
            if ..Ingredients[favIngred {
                set ..Score = ..Score + 1
                set reasons = reasons_$lb("Favourite ingredient found: "_favIngred)
            }
        }

        set ..Reason = $listtostring(reasons, ". ")

    } catch ex {
        throw ex
    }
}

/// Atualize a receita com o resultado da análise
Method UpdateRecipe()
{
    try {
        // chame a implementação de classe mãe primeiro
        do ##super()

        // adicione resultados de análises da OpenAI específicos
        set ..Recipe.Ingredients = ..Ingredients
        set ..Recipe.PreparationTime = ..PreparationTime
        set ..Recipe.Difficulty = ..Difficulty
        set ..Recipe.CuisineType = ..CuisineType

    } catch ex {
        throw ex
    }
}

/// Execute a análise usando o embedded Python + Langchain
/// do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(8)).RunPythonAnalysis(1)
Method RunPythonAnalysis(debug As %Boolean = 0) [ Language = python ]
{
    # load OpenAI APIKEY from env
    import os
    from dotenv import load_dotenv, find_dotenv
    _ = load_dotenv('/app/.env')

    # account for deprecation of LLM model
    import datetime
    current_date = datetime.datetime.now().date()
    # date after which the model should be set to "gpt-3.5-turbo"
    target_date = datetime.date(2024, 6, 12)
    # set the model depending on the current date
    if current_date > target_date:
        llm_model = "gpt-3.5-turbo"
    else:
        llm_model = "gpt-3.5-turbo-0301"

    from langchain.chat_models import ChatOpenAI
    from langchain.prompts import ChatPromptTemplate
    from langchain.chains import LLMChain

    from langchain.output_parsers import ResponseSchema
    from langchain.output_parsers import ResponseSchema

    # init llm model
    llm = ChatOpenAI(temperature=0.0, model=llm_model)

    # prepare the responses we need
    cuisine_type_schema = ResponseSchema(
        name="cuisine_type",
        description="What is the cuisine type for the recipe? \
                     Answer in 1 word max in lowercase"
    )
    preparation_time_schema = ResponseSchema(
        name="preparation_time",
        description="How much time in minutes do I need to prepare the recipe?\
                     Anwer with an integer number, or null if unknown",
        type="integer",
    )
    difficulty_schema = ResponseSchema(
        name="difficulty",
        description="How difficult is this recipe?\
                     Answer with one of these values: easy, normal, hard, very-hard"
    )
    ingredients_schema = ResponseSchema(
        name="ingredients",
        description="Give me a comma separated list of ingredients in lowercase or empty if unknown"
    )
    response_schemas = [cuisine_type_schema, preparation_time_schema, difficulty_schema, ingredients_schema]

    # get format instructions from responses
    output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
    format_instructions = output_parser.get_format_instructions()
    
    analysis_template = """\
    Interprete and evaluate a recipe which title is: {title}
    and the description is: {description}
    
    {format_instructions}
    """
    prompt = ChatPromptTemplate.from_template(template=analysis_template)

    messages = prompt.format_messages(title=self.Recipe.Title, description=self.Recipe.Description, format_instructions=format_instructions)
    response = llm(messages)

    if debug:
        print("======ACTUAL PROMPT")
        print(messages[0].content)
        print("======RESPONSE")
        print(response.content)

    # populate analysis with results
    output_dict = output_parser.parse(response.content)
    self.CuisineType = output_dict['cuisine_type']
    self.Difficulty = output_dict['difficulty']
    self.Ingredients = output_dict['ingredients']
    if type(output_dict['preparation_time']) == int:
        self.PreparationTime = output_dict['preparation_time']

    return 1
}

}

O método "RunPythonAnalysis" é onde tudo relacionado a OpenAI acontece :). Você pode executá-lo diretamente no terminal para uma receita específica:

do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12)).RunPythonAnalysis(1)

Vamos obter uma saída assim:

USER>do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12)).RunPythonAnalysis(1)
======ACTUAL PROMPT
                    Interprete and evaluate a recipe which title is: Folded Sushi - Alaska Roll
                    and the description is: Craving for some sushi but don't have a sushi roller? Try this easy version instead. It's super easy yet equally delicious!
[Video Recipe](https://www.youtube.com/watch?v=1LJPS1lOHSM)
# Ingredients
Serving Size:  \~5 sandwiches      
* 1 cup of sushi rice
* 3/4 cups + 2 1/2 tbsp of water
* A small piece of konbu (kelp)
* 2 tbsp of rice vinegar
* 1 tbsp of sugar
* 1 tsp of salt
* 2 avocado
* 6 imitation crab sticks
* 2 tbsp of Japanese mayo
* 1/2 lb of salmon  
# Recipe     
* Place 1 cup of sushi rice into a mixing bowl and wash the rice at least 2 times or until the water becomes clear. Then transfer the rice into the rice cooker and add a small piece of kelp along with 3/4 cups plus 2 1/2 tbsp of water. Cook according to your rice cookers instruction.
* Combine 2 tbsp rice vinegar, 1 tbsp sugar, and 1 tsp salt in a medium bowl. Mix until everything is well combined.
* After the rice is cooked, remove the kelp and immediately scoop all the rice into the medium bowl with the vinegar and mix it well using the rice spatula. Make sure to use the cut motion to mix the rice to avoid mashing them. After thats done, cover it with a kitchen towel and let it cool down to room temperature.
* Cut the top of 1 avocado, then slice into the center of the avocado and rotate it along your knife. Then take each half of the avocado and twist. Afterward, take the side with the pit and carefully chop into the pit and twist to remove it. Then, using your hand, remove the peel. Repeat these steps with the other avocado. Dont forget to clean up your work station to give yourself more space. Then, place each half of the avocado facing down and thinly slice them. Once theyre sliced, slowly spread them out. Once thats done, set it aside.
* Remove the wrapper from each crab stick. Then, using your hand, peel the crab sticks vertically to get strings of crab sticks. Once all the crab sticks are peeled, rotate them sideways and chop them into small pieces, then place them in a bowl along with 2 tbsp of Japanese mayo and mix until everything is well mixed.
* Place a sharp knife at an angle and thinly slice against the grain. The thickness of the cut depends on your preference. Just make sure that all the pieces are similar in thickness.
* Grab a piece of seaweed wrap. Using a kitchen scissor, start cutting at the halfway point of seaweed wrap and cut until youre a little bit past the center of the piece. Rotate the piece vertically and start building. Dip your hand in some water to help with the sushi rice. Take a handful of sushi rice and spread it around the upper left hand quadrant of the seaweed wrap. Then carefully place a couple slices of salmon on the top right quadrant. Then place a couple slices of avocado on the bottom right quadrant. And finish it off with a couple of tsp of crab salad on the bottom left quadrant. Then, fold the top right quadrant into the bottom right quadrant, then continue by folding it into the bottom left quadrant. Well finish off the folding by folding the top left quadrant onto the rest of the sandwich. Afterward, place a piece of plastic wrap on top, cut it half, add a couple pieces of ginger and wasabi, and there you have it.
                    
                    A saída deve ser um fragmento de código markdown formatado no seguinte esquema, incluindo o "```json" e "```" à esquerda e à direita:
json
{
        "cuisine_type": string  // What is the cuisine type for the recipe?                                  Answer in 1 word max in lowercase
        "preparation_time": integer  // How much time in minutes do I need to prepare the recipe?                                    Anwer with an integer number, or null if unknown
        "difficulty": string  // How difficult is this recipe?                               Answer with one of these values: easy, normal, hard, very-hard
        "ingredients": string  // Give me a comma separated list of ingredients in lowercase or empty if unknown
}

                    
======RESPONSE
json
{
        "cuisine_type": "japanese",
        "preparation_time": 30,
        "difficulty": "easy",
        "ingredients": "sushi rice, water, konbu, rice vinegar, sugar, salt, avocado, imitation crab sticks, japanese mayo, salmon"
}

Tudo bem. Parece que nosso prompt da OpenAI é capaz de retornar algumas informações úteis. Vamos executar toda a classe da análise no terminal:

set a = ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12))
do a.Run()
zwrite a

USER>zwrite a
a=37@yummy.analysis.SimpleOpenAI  ; <OREF>
+----------------- general information ---------------
|      oref value: 37
|      class name: yummy.analysis.SimpleOpenAI
| reference count: 2
+----------------- attribute values ------------------
|        CuisineType = "japanese"
|         Difficulty = "easy"
|        Ingredients = "sushi rice, water, konbu, rice vinegar, sugar, salt, avocado, imitation crab sticks, japanese mayo, salmon"
|    PreparationTime = 30
|             Reason = "It seems to be a japanese recipe!. You don't need too much time to prepare it"
|              Score = 3
+----------------- swizzled references ---------------
|           i%Recipe = ""
|           r%Recipe = "30@yummy.data.Recipe"
+-----------------------------------------------------

## Analisando todas as receitas! Naturalmente, você gostaria de executar a análise em todas as receitas que carregamos.

Você pode analisar uma variedade de IDs de receitas desta forma:

USER>do ##class(yummy.Utils).AnalyzeRange(1,10)
> Recipe 1 (1.755185s)
> Recipe 2 (2.559526s)
> Recipe 3 (1.556895s)
> Recipe 4 (1.720246s)
> Recipe 5 (1.689123s)
> Recipe 6 (2.404745s)
> Recipe 7 (1.538208s)
> Recipe 8 (1.33001s)
> Recipe 9 (1.49972s)
> Recipe 10 (1.425612s)

Depois disso, verifique novamente sua tabela de receitas e confira os resultados

select * from yummy_data.Recipe

Acho que eu poderia tentar a pizza de abóbora ou o tofu com kimchi coreano e porco :). Vou precisar conferir novamente em casa de qualquer forma :)

Observações finais

Encontre o exemplo completo em https://github.com/isc-afuentes/recipe-inspector

Com esse exemplo simples, aprendemos a usar as técnicas de LLM para adicionar recursos ou analisar partes dos seus dados no InterSystems IRIS.

Com esse ponto de partida, você pode pensar em:

• Usar a BI do InterSystems para explorar e navegar pelos seus dados usando cubos e painéis.
• Criar um webapp e fornecer IU (por exemplo, Angular). Para isso, você pode aproveitar pacotes como RESTForms2 para gerar automaticamente as APIs REST para suas classes persistentes.
• Armazenar as receitas independentemente de gostar delas e, depois, tentar determinar se uma nova receita gostará de você? Você pode tentar uma abordagem com o IntegratedML ou até mesmo um LLM, fornecendo alguns dados de exemplo e criando um caso de uso de RAG (Geração Aumentada de Recuperação).

O que mais você pode tentar? Me diga o que você acha!

Com certeza, você já se deparou com esta situação:

• Há um bug em um Sistema que você não consegue reproduzir localmente
• Você precisa executar algumas linhas na instância afetada
• Você ganha acesso completo ao Portal de Gerenciamento de Sistemas
• Mas não há terminal, console nem acesso com o Studio, Atelier ou VSCode
• Como executar algumas linhas para teste ???

• Acesse o SMP / Explorer / guia SQL= Execute Query
  •  
  •  
• Agora crie um procedimento armazenado com o código necessário
  • Não há limite de complexidade. Eu só crio um simples com resultado previsível.

  • CREATE PROCEDURE RUN.ISOS()
    

LANGUAGE OBJECTSCRIPT { For i=1:1:20 write i," > "   Write "
THANKS !" }

• Clique em EXECUTE para ver um novo procedimento *    
  •  
• Em seguida, examine esse novo procedimento e execute-o *  
  •  
• Ele é ativado com outra execução *  
  •  
• e este é o resultado *
  •  
• como você é um especialista bem instruído, limpa o ambiente depois de terminar  
  • DROP PROCEDURE RUN.ISOS
  •  

Espero que isso ajude você no futuro.
Documentação

InterSystems FAQ

Ao executar comandos do sistema operacional, use $ZF(-100).

do$ZF(-100,"",program,args) // Execute the Windows command [synchronously].

do$ZF(-100,"/ASYNC",program,args) // Executes a Windows command [asynchronously].

Ao executar comandos do shell do sistema operacional, como mkdir e copy, especifique também /SHELL.

do$zf(-100,"/shell /async","mkdir","c:\temp\x")

Consulte os seguintes documentos para obter detalhes:

Sobre $ZF(-100) [IRIS]
Sobre $ZF(-100)

Olá Comunidade,

Sabemos que você está esperando ansiosamente esse momento há um ano inteiro (e até recebemos mensagens perguntando se isso está acontecendo 😉)... Bom, o momento chegou!

Junte-se ao Advent of Code 2023 com a InterSystems e participe de nosso concurso de ObjectScript para ter a chance de ganhar prêmios fabulosos!

Oi, pessoal,

Publiquei um novo pacote no OEX.

Resumindo, é um tipo de dados de string que oferece várias opções de configuração e flexibilidade.

Caso de negócio

1. Você tem algumas classes de bibliotecas e outras estruturas reutilizáveis que usa em vários sistemas.
2. Você tem um ambiente "multi-tenant" em que uma base de código é compartilhada entre vários inquilinos, sendo que cada um tem seu próprio namespace configurado.
   1. Regras específicas e processos de negócios são armazenados no namespace desse inquilino.
   2. As estruturas de classes principais são as mesmas.
   3. Os inquilinos têm diferentes requisitos de validação de dados e alguns querem a consistência dos dados em todos os sistemas da organização.

Se você tiver seis inquilinos com diferentes níveis de validação em um número de identificação (SSN), você deve acomodá-los sem precisar criar um subconjunto de classes para cada um.

Alguns inquilinos também querem que os dados sejam depurados para garantir a consistência.

Solução do problema

Uma classe de string com a opção de configurar o tempo de compilação e de execução que pode ser alterada dinamicamente.

Essa classe oferece o seguinte

1. Defina o valor do parâmetro REGEX para a validação de expressão regular no método IsValid.
   1. Defina o REGEXMODE como "globalref", e IsValid obterá o valor de um global para usar como o padrão de expressão regular.
      1. Por exemplo, REGEXMODE = "^MyConf(""IDNumberRegex"")" Em seguida, configure o padrão nesse global e nó.
2. Defina o valor do parâmetro DATACLEANUPSEQUENCE a ser aplicado durante o método Normalize.
   1. O valor é uma %List de %Lists que contêm as instruções para $ZSTRIP.
      1. Por exemplo, DATACLEANUPSEQUENCE = "$lb($lb(""<>WC"","""",""""),$lb(""*P"","""",""-""))"
   2. Defina DATACLEANUPMODE como "globalref", e Normalize lerá a sequência de limpeza do global indicado pelo valor em DATACLEANUPSEQUENCE. Por exemplo, DATACLEANUPSEQUENCE  = "^MyConf(""LastNameCleanup"")" Em seguida, configure a sequência nesse global e nó.
      1. Por exemplo, "^MyConf(""LastNameCleanup"") = $lb($lb("*PC","","'- "),$lb("<->W","",""))
3. Defina o valor do parâmetro ADDITIONALVALIDATIONCALL como a chamada de classmethod que será feita durante IsValid, depois de todas as outras validações.
   1. O valor tem o formato "##class(My.ValidatorClass).MyClassMethod()"
   2. Defina ADDITIONALVALIDATIONMODE como "globalref", e IsValid lerá o método de validação a ser usado do global indicado pelo valor em ADDITIONALVALIDATIONCALL.
      1. Por exemplo, ADDITIONALVALIDATIONCALL= "^MyConf(""LastNameCleanup"")" Em seguida, configure a sequência nesse global e nó.
         1. Por exemplo, "^MyConf(""IDNumberValidator"") = "##class(BaseLib.Validators.ZAID).Validate()"

O repositório do GitHub contém uma demonstração completa dessa funcionalidade, além de exemplos de classes.

Obrigado

Olá, desenvolvedores. No momento, estou realizando uma demonstração sobre o desenvolvimento de uma IU front-end fazendo análise de dados e configurando um teste de desempenho com grandes objetos de dados. Portanto, o uso do utilitário Populate pode me ajudar a gerar automaticamente alguns dados de amostra com que eu possa brincar.

Neste post, gostaria de compartilhar minha experiência ao usar o utilitário Populate, incluindo o parâmetro POPSPEC.

1. No início, criei 2 classes persistentes para o suporte do utilitário Populate ( Extends (%Persistent, %Populate)): popPatient que busca preencher as informações dos pacientes e popSign para simular os dados coletados de um sensor de frequência cardíaca no paciente.    

2.1 Para deixar esta demonstração parecida com circunstâncias reais, quero adicionar o intervalo de valores das variáveis para algumas propriedades ao usar MAXVAL e MINVAL. Por exemplo, não se pode esperar que um paciente tenha mil anos de idade.

Faça o mesmo com a frequência cardíaca em BPM

2.2 Se precisamos usar um método de geração automática personalizado, utilizamos POPSPEC para definir os valores gerados. Por exemplo, temos classes pré-definidas que podem ser referenciadas diretamente e gerar números de telefone dos EUA. Porém, no meu caso, quero gerar um formato correspondente ao número de telefone australiano. Também quero registrar o horário de coleta das frequências cardíacas e criar uma lista para colocar todos os valores que quero gerar nela. Para tudo isso, precisamos usar POPSPEC para personalizar a geração de dados a partir de um método definido pelo usuário.

Nesse caso, escrevi dois classMethods simples para predefinir o formato do número de telefone e detectar o carimbo de data/hora atual como o horário de coleta da frequência cardíaca. Em seguida, adicionei o parâmetro POPSPEC à propriedade relacionada

3. Execute o método e comece a popular os dados

Você pode simplesmente inserir o comando a seguir no Terminal para popular os dados, substituindo number pelo número de valores que precisam ser preenchidos.

"do ##class(Demo.popPatient).Populate( number  )"

"do ##class(Demo.popSign).Populate( number )"

Ou você pode colocar esses dois comandos definidos em um classMethod como este e executar "do ##class(Demo.RunPopulate). StartPop ('times for patient', times for signs') 

4. Aqui está um exemplo para gerar 10 pacientes e 50 sinais de frequência cardíaca coletados

Espero que esta simples exploração possa ajudar você. Happy Coding!

Peço desculpas se isso for óbvio para programadores Python, mas, para aqueles que estão saindo do ObjectScript, esta pode ser uma dica útil.

O cenário é o desenvolvimento de alguns comandos do Embedded Python.

Testando se a funcionalidade está sendo confirmada pelo shell:

$SYSTEM.Python.Shell()
 
Python 3.9.5 (default, Mar 14 2023, 06:58:44) [MSC v.1927 64 bit (AMD64)] on win32
Type quit() or Ctrl-D to exit this shell.
>>>

Quando o Python avalia uma expressão no shell, ele imprime o resultado da expressão no terminal.

>>> 1 + 2

3

É bastante fácil avaliar e imprimir valores sem querer

>>> iris.cls("%Dictionary.MethodDefinition")._OpenId("%Library.String||LogicalToJSON",0)
# .. mas eu queria muito esse objeto para outros trabalhos

Ou seja, o que eu queria fazer era configurar uma nova variável para retornar o valor desta chamada de função:

>>> myvar = iris.cls("%Dictionary.MethodDefinition")._OpenId("%Library.String||LogicalToJSON",0)

Isso pode causar um atraso se houve muita configuração envolvida para chegar até este ponto.

A variável "_" sublinhado vem ao resgate. Isso retém o valor da última expressão avaliada por você.

Você pode salvar seu momento P&D ao executar: "[nome da variável] = _  "

>>> iris.cls("%Dictionary.MethodDefinition")._OpenId("%Library.String||LogicalToJSON",0)

# oops

>>> myvar = _

# Mantenha a calma e siga em frente ...

>>> myvar._ClassName()

'MethodDefinition

Espero que isso seja útil para alguém.

Visão geral

Com o cross-skilling do objectScript do IRIS para o Python, ficam claras algumas diferenças fascinantes na sintaxe.

Uma dessas áreas é como o Python retorna Tuplas de um método com desempacotamento automático.

Efetivamente, isso se apresenta como um método que retorna vários valores. Que invenção incrível :)

out1, out2 = some_function(in1, in2)

O ObjectScript tem uma abordagem diferente com o ByRef e os parâmetros de saída.

Do ##class(some_class).SomeMethod(.inAndOut1, in2, .out2)

Onde:

• inAndOut1 é o ByRef
• out2 é a saída

O ponto à esquerda (".") na frente do nome da variável passa o ByRef e a saída.

A finalidade deste artigo é descrever como a comunidade do utilitário PyHelper foi otimizada para oferecer uma maneira pythônica de aproveitar o ByRef e os parâmetros de saída. Ele dá acesso a %objlasterror e tem uma abordagem para lidar com o tipo None do Python.
 

ByRef de exemplo

A invocação normal para o embedded python seria:

oHL7=iris.cls("EnsLib.HL7.Message")._OpenId('er12345')

Quando a abertura desse método falha, a variável "oHL7" é uma string vazia.
Na assinatura desse método, há um parâmetro de status disponível para o object script que fornece uma explicação do problema exato.
Por exemplo:

• O registro pode não existir
• Não foi possível abrir o registro no modo de simultaneidade exclusiva padrão ("1"), dentro do tempo limite

ClassMethod %OpenId(id As %String = "", concurrency As %Integer = -1, ByRef sc As %Status = {$$$OK}) As %ObjectHandle

O método TupleOut pode ajudar no retorno do valor do argumento sc, de volta a um contexto python.
 

> oHL7,tsc=iris.cls("alwo.PyHelper").TupleOut("EnsLib.HL7.Message","%OpenId",['sc'],1,'er145999', 0)
> oHL7
''
> iris.cls("%SYSTEM.Status").DisplayError(tsc)
ERROR #5809: Object to Load not found, class 'EnsLib.HL7.Message', ID 'er145999'1
```

A lista ['sc'] contém um único item nesse caso. Ela pode retornar vários valores Byref, e na ordem especificada. O que é útil para descompactar automaticamente as variáveis pretendidas do Python.

Exemplo de como lidar com um parâmetro de saída

Código em Python:

> oHL7=iris.cls("EnsLib.HL7.Message")._OpenId('145')
> oHL7.GetValueAt('<%MSH:9.1')
''

A string retornada está vazia, mas isso se deve ao elemento realmente estar vazio OU algo que deu errado.
No object script, há também um parâmetro de status de saída (pStatus) que pode ser acessado para determinar essa condição.

Código em object script:

> write oHL7.GetValueAt("<%MSH:9.1",,.pStatus)
''
> Do $System.Status.DisplayError(pStatus)
ERROR <Ens>ErrGeneral: No segment found at path '<%MSH'

Com TupleOut, a funcionalidade equivalente pode ser obtida ao retornar e descompactar ambos o valor de retorno do método E o parâmetro de saída do status.

Código em Python:

> hl7=iris.cls("EnsLib.HL7.Message")._OpenId(145,0)
> val, status = iris.cls("alwo.PyHelper").TupleOut(hl7,"GetValueAt",['pStatus'],1,"<&$BadMSH:9.1")
> val==''
True
> iris.cls("%SYSTEM.Status").IsError(status)
1
> iris.cls("%SYSTEM.Status").DisplayError(status)
ERROR <Ens>ErrGeneral: No segment found at path '<&$BadMSH'1

###Variável especial %objlasterror

No objectscript, há acesso a variáveis de porcentagem no escopo do método.
Há cenários em que detectar ou acessar a variável especial %objlasterror é útil após chamar uma API de terceiros ou CORE
O método TupleOut permite o acesso a %objlasterror, como se tivesse sido definido como um parâmetro de saída, ao invocar métodos do Python

> del _objlasterror

> out,_objlasterror=iris.cls("alwo.PyHelper").TupleOut("EnsLib.HL7.Message","%OpenId",['%objlasterror'],1,'er145999', 0) 

> iris.cls("%SYSTEM.Status").DisplayError(_objlasterror)
ERROR #5809: Object to Load not found, class 'EnsLib.HL7.Message', ID 'er145999'1

Quando None não é uma String

O TupleOut lida com as referências a None do Python como objectscript indefinido. Isso permite que os parâmetros sejam padronizados e os métodos se comportem de forma consistente.
Isso é importante, por exemplo, com %Persistent::%OnNew, em que o método %OnNew não é acionado quando None é fornecido para initvalue, mas seria acionado se uma string vazia fosse fornecida.

No objectscript, a implementação pode dizer:

do oHL7.myMethod("val1",,,"val2")

Observe a ausência de variáveis entre vírgulas.

O TupleOut facilita o mesmo comportamento com:

Python:

iris.cls("alwo.PyHelper").TupleOut(oHL7,"myMethod",[],0,"val1",None,None,"val2")

Outra maneira de considerar isso é poder ter uma implementação de uma linha de código de invocação, com um comportamento flexível dependendo da pré-configuração das variáveis:

Object Script:

set arg1="val1"
kill arg2
kill arg3
set arg4="val2"
do oHL7.myMethod(.arg1, .arg2, .arg3, .arg4)

O TupleOut facilita o mesmo comportamento com:

Python:

arg1="val1"
arg2=None
arg3=None
arg4="val2"
iris.cls("alwo.PyHelper").TupleOut(oHL7,"myMethod",[],0,arg1,arg2,arg3,arg4)

Lista e dicionários

Ao lidar com parâmetros para entrada, ByRef e saída, o TupleOut utiliza o mapeamento automático do PyHelper entre:
Listas do IRIS e do Python
Arrays do IRIS e do Python
Onde é preciso sempre usar strings para representar as chaves do dicionário ao passar de Arrays do IRIS para tipos Dict do Python.

Conclusão

Espero que este artigo ajude a inspirar novas ideias, discussões e sugestões sobre o Embedded Python.

Também espero que incentive a explorar a flexibilidade do IRIS em se adaptar facilmente para enfrentar novos desafios.

Como observado no artigo anterior, a Native API possui algumas limitações.
Portanto, fiz algumas pesquisas sobre uma interface mais semelhante a um terminal que me forneça acesso como um console ou o terminal IRIS para permitir meu $QUERY em um global e outros comandos úteis que não são suportados/mapeados na NativeAPI para ObjectScript.

As ferramentas básicas estão bem preparadas e disponíveis.

• Connection() cria uma partição totalmente operacional e estável para mim.
• Function() permite chamar qualquer rotina ou método de que eu preciso.
• similar a ClassMethodValue e ClassMethodVoid

Esta pergunta originalmente apareceu nos comentários do post:Download globals from a particular server

Este artigo foi inspirado por uma pergunta recente feita por @Evgeny.Shvarov.
Download globals from a particular server
Não se trata de um código de "clique e execute", mas sim de um rascunho que requer ajustes para atender às suas necessidades específicas. Você precisa adicionar...

InterSystems FAQ

Se o valor de uma variável local é um OREF ou não, pode ser determinado usando $IsObject(). Seja v a variável que você deseja verificar,

$IsObject(v)=1// v is an OREF$IsObject(v)=0// v is not an OREF$IsObject(v)=-1// v is an OREF but does not point to a valid object

Observe que $IsObject(v) dará um erro UNDEFINED se v for indefinido.

Para evitar erros UNDEFINED, é recomendado o uso do $Get assim:

$IsObject($Get(v))

Veremos a seguir como o InterSystems IRIS aliado com Machine Learning pode transformar para melhor a educação do Brasil e do mundo

. .

O video de apresentação:

Educação Integrada com InterSystems IRIS

A ideia é integrar a educação usando InterSystems IRIS para permitir a criação de uma plataforma completa para gestão, análise, melhoria e transformação da educação. Com o InterSystems IRIS, seria possível integrar dados de diferentes fontes, como informações sobre alunos, professores, diretores, escolas, faculdades, cursos, entre outros, em um único lugar.

Nós sabemos que a educação é um setor de extrema importância para a sociedade, e pode ser considerado um negócio lucrativo não só financeiramente, mas também em termos de desenvolvimento social e econômico, por isso escolhi este caso de negócio. A pricinpal abordagem tecnólogica usada aqui é o Machine Learning, pois a ideia é que ferramentas de IA sejam usadam para melhorar a educação humana e não o contrário.

O projeto envolve combinar InterSystems IRIS e Machine Learning, além de outras abordagens técnologicas para criar uma plataforma de educação completamente integrada, onde todas as instituições de ensino do país estaram ligadas a plataforma, para permitir a integração de milhares de dados educacionais, que seriam usados para se servir ferramentas de ensino, análise e gestão da educação de um jeito nunca visto antes, utilizando do Machine Learning para se prever problemas e apresentar soluções que seriam capazes de melhorar completamente o ensino do Brasil.

Usar e desenvolver ferramentas de IA para colaborar com a evolução humana, não para se aproveitar de suas fraquezas.

É um fato que tecnologias relacionadas à Inteligência Artificial estão em constante evolução, desta forma se torna cada vez mais necessário melhorar a eficiência da educação humana, para que humanos evoluam junto e não fiquem para trás. Sendo assim, em um mundo tão cheio de informações e conhecimento, precisamos de ferramentas poderosas de processamento de dados, integração e análise em tempo real, e é ai que entra o InterSystems IRIS.

Graças ao InterSystems IRIS podemos criar uma plataforma global de educação, integrar dados de diferentes fontes, executar análises em tempo real e fornecer insights acionáveis para tomada de decisão rápida e precisa. Poderemos usar diferentes abordagens tecnológicas em conjunto com o InterSystems IRIS, esta plataforma seria usada por escolas, faculdades e outras instituições de ensino, abrindo caminho para trazer a gamificação na sua forma máxima em todas as fases da educação, aumentando o engajamento das pessoas no ensino e na educação de qualidade.

Graças ao InterSystems IRIS e o Machine Learning podemos mudar a realidade de países como o Brasil, um país que sofre com uma educação de péssima qualidade há muitos anos, desta forma vamos criar uma plataforma colaborativa e integrada de educação, que vai salvar a educação do Brasil.

Arquitetura

A arquitetura (modelo lógico) da plataforma Educação Integrada InterSystems IRIS vai envolver combinar diferentes componentes tecnológicos para atender às necessidades específicas deste projeto. Em termos gerais, a plataforma tem a seguinte arquitetura:

InterSystems IRIS:

Nossa plataforma é construida em cima do InterSystems IRIS, o que facilita a criação de aplicativos habilitados para aprendizado de máquina de alto desempenho que conectam dados e silos de aplicativos.

Com ele vamos ter gerenciamento de banco de dados de alto desempenho, interoperabilidade e recursos de análise, todos integrados desde o início para acelerar e simplificar os aplicativos com uso intensivo de dados mais exigentes e integra-se perfeitamente a infraestrutura existente.

Front-end:

O front-end é construído usando o framework Angular, que vai permitir que se desenvolva uma interface amigável e intuitiva para os usuários finais da plataforma, incluindo professores, alunos, pais, diretores, empresas e funcionários públicos e privados e etc.

Back-end:

O back-end é construído usando InterSystems API Manager e ObjectScript. Sabendo que O API Manager usa contêineres, precisaremos trabalhar com contêineres e Docker também.

Observação: O InterSystems API Manager (IAM) é um componente independente que a InterSystems fornece para uso com os produtos InterSystems IRIS. Ele permite que se monitore, controle e administre o tráfego de API baseado em HTTP, o InterSystems API Manager (IAM) permite que se aproveite ao máximo os microsserviços e APIs que são expostos ou consumidos por aplicativos InterSystems IRIS.

O InterSystems API Manager é uma solução de gerenciamento de API que oferece recursos de segurança, autenticação, autorização e monitoramento de API em tempo real, enquanto o ObjectScript é uma linguagem de programação multi-paradigma que é usada para desenvolver aplicativos para a plataforma InterSystems IRIS. No caso também podemos trazer mais do Machine Learning caso haja necessidades especifícas, pois o InterSystems IRIS também oferece suporte integrado para Python e outras linguagens externas.

O API Manager fornece uma interface para gerenciar, autenticar e monitorar as APIs desenvolvidas em ObjectScript ou em outras linguagens, já o ObjectScript fornece a lógica de negócios para as APIs. Quando uma solicitação é feita a uma API gerenciada pelo API Manager, o API Manager encaminha a solicitação para o serviço ObjectScript correspondente. Depois que o serviço processa a solicitação, ele retorna uma resposta ao API Manager, que por sua vez manda a resposta de volta ao cliente. Isso permite que o ObjectScript se concentre na lógica de negócios, enquanto o API Manager gerencia a autenticação, autorização, segurança e monitoramento de API. Além de ser excelente para definir os consumidores para alunos, professores, pais e etc; Eles representam “aplicativos diferentes” que farão chamadas de API para o API Manager.

Banco de dados:

O banco de dados é hospedado no InterSystems IRIS. A plataforma de dados InterSystems IRIS fornece uma arquitetura multimodelo que permite usar o modelo de dados que melhor se adapta a cada tarefa ( relacional, de objeto ou até mesmo acesso direto/nativo ) tudo acessível por meio do idioma escolhido. que oferece alta escalabilidade, segurança e disponibilidade para o banco de dados.

Hoje o InterSystems IRIS também permite a integração direta com o Kafka, o que nos permite ter aplicativos de streaming em tempo real de alto desempenho.

Machine Learning:

Nossa plataforma também utiliza o InterSystems IntegrateML, que oferece recursos avançados de Machine Learning para análise de dados e previsão de tendências. IntegratedML é um novo recurso do InterSystems IRIS que permite que os desenvolvedores SQL desenvolvam facilmente modelos de aprendizado de máquina com apenas alguns comandos semelhantes a SQL. Os modelos de aprendizado de máquina podem ser integrados perfeitamente em aplicativos e produções para serem executados em tempo real em resposta a eventos e transações. Desta forma vamos poder oferecer para todos os usuários da plataforma uma ferramenta poderosa de IA para colaborar com o progresso da evolução humana, oferecendo análises de desempenho, dicas e permitindo que se ofereça uma atenção individual para as dificuldades em particular de cada indivíduo.

IoT:

A plataforma é integrada com sensores IoT, para rastrear o desempenho dos alunos em tempo real. Isso é usado para análise, gamificação, previsões do IntegrateML, planos de segurança, melhora da experiência dos alunos, monitoramento de energia, monitorar temperatura e umidade, gerenciar presença, monitorar o uso das instalações e etc. Como nosso modelo de comunicação terá uma arquitetura centralizada, teremos várias instâncias InterSystems IRIS, desta forma cada instituição terá sua própria infraestrutura IoT de forma independente.

Blockchain:

A plataforma poderá também ser integrada com a tecnologia Blockchain para garantir a segurança dos dados dos usuários e a transparência em todo o sistema educacional. A blockchain poderá, será utilizada para garantir a integridade e a segurança dos registros e transações realizadas pelos usuários, como alunos, professores, pais e outros. Por exemplo a blockchain poderá ser utilizada para registrar a emissão de diplomas e certificados digitais, garantindo a autenticidade dos documentos e prevenindo fraudes.

Com essa arquitetura vamos poder combinar diferentes tecnologias e abordagens tecnológicas para fornecer uma plataforma robusta e escalável para gerenciamento, análise, controle e melhoria da educação no país. Ainda poderemos integra-la com outras plataformas e serviços externos, como empresas e o governo federal, para permitir que a plataforma Educação Integrada InterSystems IRIS ofereça uma experiência de usuário ainda mais abrangente e enriquecedora.

Observação: Pode haver a necessidade de se trabalhar com outras linguagens e tecnologias, por isso na imagem abaixo podemos ter uma ideia melhor do que é possivel com InterSystems IRIS

Funcionalidades do InterSystems IRIS que são de extrema importância para o funcionamento desta plataforma:

1. Ferramentas de colaboração: Algo muito importante é o trabalho em equipe, que é crucial para um projeto como esse. E como o InterSystems IRIS oferece várias ferramentas de colaboração, como mensagens, notificações e bate-papo, que permitem que as equipes trabalhem juntas de maneira mais eficiente seria possível com toda certeza desenvolver um projeto tão grande como este.

2. Armazenamento de dados: Precisamos de um armazenamento de dados muito bom e como o InterSystems IRIS tem um armazenamento de dados de alto desempenho e escalável que permite armazenar dados de várias fontes em um único local teremos o necessário, com toda certeza.

3. Acesso a dados em tempo real: O setor da Educação demanda uma tomada de decisão muito precisa e inteligente. Desta forma temos aqui mais um motivo para escolher o InterSystems IRIS, pois ele nos permite ter o acesso a dados em tempo real de várias fontes, incluindo dados estruturados e não estruturados. Isso permite se tomar decisões informadas em tempo real com base em insights valiosos.

4. Integração com outros sistemas: Não pode parar, não pode perder, precisa integrar. O InterSystems IRIS pode ser facilmente integrado com sistemas de terceiros. Desta forma as instituições vão poder estender soluções existentes e aumentem sua eficiência operacional. O que é muito importante, pois hoje já temos muitos sistemas em uso no setor educacional, então poderemos aumentar a eficiência de grande parte deles e/ou liberar mais informações valiosas de tomada de decisão.

5. Monitoramento e gerenciamento de desempenho: O MEC e as instituições vão precisar de ferramentas de monitoramento e gerenciamento de desempenho que permitem que se monitore e otimize o desempenho dos sistemas em tempo real, o que é outra funcionalidade do InterSystems IRIS.

6. Desenvolvimento de aplicativos móveis: Uma das ideias é que pais possam acompanhar o desempenho de seus filhos em qualquer lugar, usando um smartphone por exemplo e como o InterSystems IRIS permite o desenvolvimento de aplicativos móveis de alta qualidade e seguros que podem ser facilmente integrados com outros sistemas, nossa plataforma poderá oferecer aplicativos móveis para todos: pais, professores, alunos e outros.

7. Segurança avançada: Precisamos de total segurança em uma platforma como esta, é um setor muito importante. InterSystems IRIS oferece recursos de segurança avançados, como autenticação, autorização e criptografia de dados, garantindo que os dados sejam mantidos seguros.

8. Escalabilidade: Nossa plataforma precisa ser altamente escalável, ou seja, tem que ter condições para crescer de forma uniforme ou para suportar um aumento de carga e ser capaz de lidar com grandes volumes de dados e tráfego de aplicativos, permitindo que a plataforma cresça e se adapte às necessidades em constante mudança do setor educacional. Algo que é totalmente possível no InterSystems IRIS.

9. Processamento de fluxo de dados em tempo real: O InterSystems IRIS permite o processamento de fluxo de dados em tempo real, o que é ideal para este projeto que exige análise de dados em tempo real, esta plataforma seria uma grande ferramenta de mudança, e teria grande importância na sociedade, além de trabalhar com muitas tecnologias e processar grandes quantidades de dados, então com toda certeza esta capacidade do InterSystems IRIS é crucial.

10. Business Intelligence (BI) e análise avançada: O InterSystems IRIS oferece recursos avançados de BI e análise, permitindo que a plataforma crie relatórios, dashboards e análises avançadas de seus dados. Isso ajudaria as instituições e orgãos responsáveis a tomar decisões informadas com base em insights valiosos.

11. Integração de sistemas legados: O InterSystems IRIS oferece recursos de integração que permitem que as instituições integrem facilmente seus sistemas legados com sistemas modernos e em nuvem, aumentando a eficiência operacional e reduzindo custos.

12. Desenvolvimento de aplicações web: Como vimos na arquitetura, a principal tecnologia de front-end escolhida foi o Angular e apesar de no diagrama apresentarmos uma arquitetura de um cliente web externo ao servidor, também podemos ter um cliente web servido pelo InterSystems IRIS. O InterSystems IRIS permite o desenvolvimento de aplicações web de alta qualidade e seguras, utilizando tecnologias modernas como Angular, React, Vue.js e outros.

13. Automação de processos empresariais: Educação também é negócio, um negócio lucrativo, desta forma serão necessários recursos de automação de processos empresariais (BPM) que permitem que as instituições automatizem e gerenciem seus processos de negócios de forma mais eficiente. O InterSystems IRIS oferece!

14. Suporte para múltiplos idiomas e regiões: O InterSystems IRIS suporta múltiplos idiomas e regiões, permitindo que a plataforma atenda clientes e usuários em todo o mundo.

15. Regras de Negócios(Business Rules): Com esta funcionalidade, o InterSystems IRIS permite que usuários não técnicos alterem o comportamento dos processos de negócios em pontos de decisão específicos. Sendo possível alterar a lógica da regra instantaneamente, usando o editor de regras no portal de gerenciamento. Imagine que uma instituição de ensino que está em todo o Brasil acaba de lançar um programa de bolsas de estudo, mas cada "filial" desta instituição tem seus próprios critérios de aceitação de alunos, com as regras de negócios suportamos essa divisão de responsabilidade. Portanto, é possível que analistas de negócios em vários locais regionais executem o Editor de Regras para modificar suas cópias da regra para fornecer diferentes critérios específicos apropriados para suas localidades.

16. Encryption (Criptografia): Uma plataforma como esta vai lidar com muitos dados valiosos, por isso precisamos protege-lá contra acesso não autorizado a dados em disco, por isso está funcionalidade do InterSystems IRIS de criptografia é muito importante. O InterSystems IRIS fornece criptografia de chave gerenciada , um conjunto de tecnologias que protegem os dados em repouso.

17. Mirroring and High Availability: Outra funcionalidade muito importante do InterSystems IRIS é o espelhamento e alta disponibilidade, está pode ser considerada uma plataforma de missão crítica e precisa estar disponível 24 horas por dia, 7 dias por semana. O espelhamento da plataforma de dados IRIS da InterSystems fornece failover automático rápido, confiável e robusto com base na replicação lógica de dados. Caso o pior aconteca e um grande evento derrube um aplicativo ou serviço da nossa plataforma, o espelhamento oferece uma rápida recuperação de desastres.

Mais ferramentas e funcionalidades InterSystems IRIS interessantes que seram úteis para a plataforma:

InterSystems IRIS Adaptive Analytics:

• O InterSystems IRIS Adaptive Analytics é uma extensão opcional que fornece uma camada de modelo de dados virtual orientada para os negócios entre o InterSystems IRIS e as populares ferramentas de cliente Business Intelligence (BI) e Artificial Intelligence (AI). O BI pode ser usado para criar painéis de controle e relatórios personalizados.

InterSystems DeepSee:

• Esta ferramenta pode ser usada para criar visualizações de dados interativas e em tempo real, permitindo que os usuários do sistema explorem os dados de forma mais aprofundada e tomem decisões mais informadas.

InterSystems HealthShare:

• O HealthShare, que é muito mais do que uma funcionalidade, pode ser usado para integrar dados de saúde dos alunos, permitindo que os médicos e os professores monitorem o bem-estar físico e mental dos alunos e ajudem a identificar e tratar problemas de saúde. Isso aqui só se o Brasil der mais um passo para o futuro utilizando InterSystems na saúde também, mas mesmo que não, sabemos que continua sendo possível graças a capacidade de integração com outros sistemas do InterSystems IRIS.

System Alerting and Monitoring:

• System Alerting and Monitoring ( SAM ) é um componente independente que a InterSystems fornece para monitorar os produtos da InterSystems. Com este, mesmo que nossa plataforma seja executada em um par espelhado local ou na nuvem com vários aplicativos e servidores de dados, poderemos usar o SAM para monitorar as instâncias InterSystems IRIS. Usando o aplicativo da web SAM para visualizar métricas de desempenho em tempo real para clusters e instâncias.

InterSystems Reports

• Como estamos lidando aqui com uma área de grande importância para a sociedade, com papel direto do governo precisamos de uma uma solução de relatórios moderna e robusta para garantir eficiência e segurança da plataforma e dar todo respaldo burocratico necessário. Que torna se possível graças ao InterSystems Reports, que é uma ferramenta de geração de relatórios para a plataforma de tecnologia InterSystems IRIS. Com o InterSystems Reports, é possível criar relatórios com gráficos, tabelas, imagens e outros elementos personalizados, além de definir layouts específicos para diferentes tipos de relatórios. A ferramenta também oferece suporte para relatórios em vários formatos, incluindo PDF, HTML, Excel e CSV, entre outros.

InterSystems IRIS® Natural Language Processing (NLP)

• Análise de Texto (Processamento de Linguagem Natural), com esta tecnologia o InterSystems IRIS permite que se execute análise de texto em fontes de dados não estruturadas em uma variedade de linguagens naturais sem qualquer conhecimento prévio de seu conteúdo. Algo muito útil para as instituições de ensino que muitas vezes podem precisar de informações sobre o conteúdo de textos diversos, isso permite que se descubra informações úteis sobre o conteúdo de um grande número de documentos de texto sem nenhum conhecimento prévio do conteúdo dos textos.

A ferramenta InterSystems IRIS SQL Search

• Esta ferramenta integra-se com o InterSystems IRIS Natural Language Processor (NLP) para executar operações de pesquisa de texto com reconhecimento de contexto em dados não estruturados, com recursos como pesquisa difusa, expressões regulares, lematização e decomposição. Esse recurso é fundamental para acessar o conteúdo de grandes volumes de texto armazenados em SQL.

PMML (Predictive Modeling Markup Language)

• Como nossa plataforma servirá várias instituições de ensino que precisam trabalhar com análise e ciência de dados de forma otimizada, precisamos de um padrão que possibilite que modelos de mineração de dados e estatísticos possam ser compartilhados entre as aplicações de diferentes fornecedores. A maneira de fazer isso é usando PMML, que é suportado pela plataforma de dados InterSystems IRIS.

AutoML

• Nossa! Cada vez mais imprecionado com o InterSystems IRIS, agora temos aqui mais uma funcionalidade super legal que será muito útil para uma plataforma como está, intimamente ligada ao machine learning. O AutoML é um sistema automatizado de aprendizado de máquina desenvolvido pela InterSystems, alojado na plataforma de dados InterSystems IRIS. Ele foi projetado para criar rapidamente modelos preditivos precisos, automatizando vários componentes-chave do processo de aprendizado de máquina. Depois de treinar o modelo com o AutoML, vamos poder implantá-lo facilmente usando a sintaxe SQL fornecida pelo IntegratedML. Isso é muito útil, imagine quanto tempo vamos economizar, vamos poder treinar diversos modelos relacionados a educação como: Modelo preditivo de desempenho acadêmico, Modelo preditivo de retenção de alunos, Modelo preditivo de engajamento, Modelo preditivo de recomendação de conteúdo, Modelo preditivo de detecção de plágio, Modelo preditivo de detecção de uso de IA na geração de textos e etc. tudo de forma automatizada. Para poder oferecer diversas ferramentas incríveis para transformar a educação totalmente.

Agora que vimos muitas funcionalidades do InterSystems IRIS que serão essenciais para este caso, vamos tentar vislumbrar como esta ideia pode transformar a educação:

Precisamo integrar em uma única plataforma toda a educação do país, escolas (públicas e privadas), faculdades (públicas e privadas), enfim todas as Instituições Credenciadas no MEC - Ministério da Educação, a ideia é que esta plataforma seja cedida pelo MEC, assim cada instituição teria sua própria instância.

Será preciso configurar as instâncias do IRIS para se comunicarem por meio de APIs e trocarem informações relevantes, como informações do aluno ou do professor.

A autenticação pode ser implementada para permitir que os usuários finais visualizem apenas os dados aos quais têm acesso, dependendo de seus perfis e funções (InterSystems API Manager). Por exemplo, um professor só poderia acessar os dados dos alunos que estão em suas turmas, enquanto um diretor poderia ter acesso a todos os dados dos alunos em sua escola.

Assim configurando de forma adequada as instâncias do InterSystems IRIS podemos fazer com que elas se comuniquem e troquem informações para fornecer uma visão unificada e completa do sistema educacional, permitindo que os usuários finais acessem facilmente as informações de que precisam, independentemente de sua localização física.

Vejamos:

Vamos integrar as instituições de todo o país para oferecer ferramentas de análise, educação, supervisão e outras. Teremos dados de alunos e instituições como por exemplo notas, perfil, ocorrências escolares, faltas, dados de IoT e etc; para por meio de Inteligência Artificial oferecer análises de desempenho e de pontos a melhorar, entre outras.

Será dividido entre interfaces especificas:

• Pais - Teriam acesso à informações referentes aos seus filhos.
• Professores - Teriam acesso à informações de todos seus alunos, podendo adicionar dados como notas.
• Alunos - Poderiam acompanhar seu desempenho, receber dicas, tarefas e etc.
• Diretores - Teriam uma grande ferramenta de Acompanhamente e análise.
• Orgãos Responsáveis - Teriam uma visão geral da educação no país.

Com isso podemos dar a sociedade, uma ferramenta completa de educação, para acompanhar, receber dicas, análises, para oferecer materias de apoio com base no desempenho particular de cada um, podendo dar atenção específica para cada pessoa.

Também será algo gameficado, com pontuação, prêmios para os melhores desempenhos, incentivando o aprendizado e o bom comportamento, onde as pontuações e os dados de cada individuo seriam importantes para toda a vida profissional, sendo usado como complemento de notas obtidas em provas de admissão de faculdades e para seletivas de oportunidades de emprego.

Aqui temos um adendo:

• Podemos integrar também dados das empresas, referente à vagas de emprego, permitindo que as empresas tenha acesso a uma interface de seleção de candidatos, com varios filtros, IA para seleção dos candidatos que mais se encaixam no perfil procurado.

• E do lado dos alunos, estes poderiam fazer buscas por oportunidades, receber propostas de emprego e estágios, receber uma análise indicando onde ele precisa melhorar para aumentar suas chances na vaga que ele almeja.

Sabemos que emprego é o que não falta, o que falta é mão de obra qualificada, assim com esta plataforma, que só é possível graças ao InterSystems IRIS, podemos integradar os dados valiosos para tomada de decisão tanto de empresas na hora de escolher um candidato, como de instituições de ensino na hora de selecionar o que será ensinado em sala de aula e também claro do cidadão na hora de traçar seus objetivos para seu futuro profissional.

Assim temos em mãos a oportunidade de mudar tudo, inclusive o entusiasmo das crianças na hora de estudar, pois está será uma plataforma cheia de gamificação, sabemos que o mundo de hoje oferece muitas distrações para as crianças, por isso precisamos urgentemente atrair as crianças para um ambiente saudável, educativo e ao mesmo tempo divertido. Por isso nossa plataforma terá também a gamificação na sua forma máxima, com emblemas, pontuações, jogos educativos, prêmios e etc. Daremos valor ao bom comportamento, as boas notas, ao trabalho em equipe, tudo que um ser humano precisa para viver bem em uma sociedade saudável pode e deve ser desenvolvido nas escolas e é preciso mostrar para as crianças que isso tem valor, e não tem jeito melhor que com gameficação.

Outra coisa importante são os pais, que muitas vezes negligenciam ou delegam a educação dos seus filhos, com esta plataforma mudamos isso, trazendo os pais para mais perto da escola, dos professores e da educação dos seus filhos, com dicas, análises, comunicação e claro gameficação. Que tal também dar prêmios aos pais pelo desempenho de seus filhos? que tal descontos em supermercados? equipamentos tecnológicos?

Como estamos falando aqui de uma plataforma ligada diretamente aos governos municipais, estaduais e federal, esta parte de prêmios poderia vir integrada ao Cadastro Único para Programas Sociais (CadÚnico), no caso do Brasil, que é um instrumento de coleta de dados e informações que objetiva identificar todas as famílias de baixa renda existentes no país para fins de inclusão em programas de assistência social e redistribuição de renda. Integrar esses dados à plataforma para que os governos valorizem pais dedicados à educaçãos de seus filhos e alunos com ótimo desempenho.

Desafios

Sabendo que o caso de negócio escolhido aqui foi no setor da educação e que este caso foi escolhido pois é um setor de extrema importância para sociedade, listo abaixo os desafios encontrados:

1. O primeiro desafio que podemos perceber em um projeto como este, está no fato de termos diferentes tipos de instituições de ensino no país, públicas, privadas e sem fins lucrátivos. E elas precisam estar, ao mesmo tempo, integradas e independentes. Por isso o InterSystems IRIS é tão importante, pois permite configurar as várias instâncias de forma que o usuário final terá uma visão unificada da plataforma, mesmo que cada instituição tenha sua própria instância InterSystems IRIS. Assim poderemos ter uma instância central ligada ao MEC que além de ter dados que são de responsábilidade do MEC, poderá consumir APIs das outras instâncias para obter os dados necessários e fornecer uma camada adicional de segurança e gerenciamento de acesso para as diferentes instâncias. Desta forma o front-end se comunica com a instância central, que é responsável por receber as solicitações do usuário final, processá-las e buscar as informações necessárias nas instâncias independentes e em si mesma em alguns casos. A instância central então retorna a resposta ao front-end, que apresenta as informações ao usuário final de forma unificada e amigável. Assim nosso modelo de comunicação terá uma "arquitetura centralizada".

2. O segundo desafio se trata do fato de que hoje nas instituições provavelmente existem sistemas de diferentes fornecedores e com diferentes estruturas de dados que precisam ser integrados na plataforma, o que pode levar a muitos desafios relacionados a identificação de sistemas que precisam ser atualizados ou substituídos. O que é algo que pode ser resolvido de forma objetiva se levarmos em conta que o modelo educacional que temos hoje está obsoleto e precisamos substituir, se não todos, grande parte desses sistemas, para integrar tudo na nova plataforma, além claro do fato desta nova plataforma ser construido em cima do InterSystems IRIS que nos oferece uma interoperabilidade sem igual. Desafios aparecem, mas o InterSystems IRIS tem a solução.

3. O terceiro é a questão da segurança, nossa plataforma precisa ser altamente segura para garantir que as informações pessoais de alunos, professores e outros estejam protegidas, além de garantir que apenas usuários autorizados tenham acesso a informações confidenciais. O que é algo que mais uma vez é facilitado pelo InterSystems IRIS. Mais abaixo vamos falar um pouco mais sobre isso.

Segurança, APIs e Modelo de Comunicação

Precisamos que nossa plataforma seja muito segura, saiba lidar com diferentes instâncias e que ao mesmo tempo, na percepção do usuário final, seja unificada.

Sabemos até aqui que está plataforma terá uma instância central que ficará sobre responsabilidade do MEC, e várias instâncias independentes e padronizadas sobre responsabilidade das instituições, desta forma vamos exemplificar abaixo como isso vai funcionar:

Para isso será preciso definir uma estrutura padronizada de APIs ao implementar as instâncias das instituições, para que a integração com a instância central seja realizada de maneira eficiente.

Assim ao cadastrar uma nova instituição na plataforma, será necessário incluir as informações referentes à API dessa instituição no banco de dados da instância central, permitindo que a comunicação entre as instâncias seja realizada de maneira adequada.

Outra coisa, é importante criar uma lógica de busca das informações de endpoint no banco de dados central, para que as informações sejam atualizadas automaticamente e o usuário final tenha acesso às informações da instituição correta.

Para implementar essa solução, será necessário utilizar o InterSystems API Manager e o ObjectScript para realizar a comunicação e integração entre as instâncias e o banco de dados central, a ideia é que o cadastro do usuário seja realizado na instância central, que poderá se comunicar também com outros serviços do governo para validar o cadastro, hoje no Brasil isso pode ser feito usando o gov.br que oferece um ambiente de autenticação digital único do usuário aos serviços públicos digitais, ou seja, com um único usuário e senha você poderá utilizar todos os serviços públicos digitais que estejam integrados com a plataforma GOV.BR. Fornece um nível de segurança compatível com o grau de exigência, natureza e criticidade dos dados e das informações pertinentes ao serviço público solicitado, assim, uma vez cadastrado, o usuário poderá ter acesso a todas as instituições do país diretamente na plataforma, podendo acessar seus dados de instituições onde está matriculado.

Desta forma quando uma pessoa realizar a matrícula em uma determinada instituição, um novo cadastro é gerado na instância local dessa instituição que vai validar os dados do aluno na instância central que por sua vez vai salvar a nova instituição nos dados do aluno para autenticação posterior.

Com esta lógica, precisamos que as instâncias das instituições disponibilizem as suas APIs e forneçam as credenciais de acesso para a instância central, teremos assim APIs especifícas e outras que possam vir a ser implementadas pelas instituições, também precisamos que cada instância das instituições de ensino forneça um serviço de autenticação integrado à plataforma central. Isso poderia ser feito usando um protocolo padrão, como OAuth 2.0, que permitiria que a instância central se autenticasse na instituição de ensino em nome do usuário, que poderá ser um diretor, um professor, aluno ou pai/mãe, funcionários e outros.

Uma vez autenticado, o sistema iria verificar em quais instituições o usuário tem acesso e mostrar apenas as informações relevantes para ele. Isso será implementado em ObjectScript usando uma combinação de APIs RESTful e lógica de negócios personalizada.

Supondo que um usuário faça login na plataforma central e seja autenticado com sucesso em uma instituição de ensino. A plataforma poderia então consultar um serviço RESTful na instituição para obter uma lista de cursos nos quais o usuário está matriculado. Essa solução garante que os usuários tenha acesso somente às informações relevantes para eles.

Com base nessa lista, a plataforma poderia exibir apenas os cursos relevantes para o usuário e ocultando todas as informações de outras instituições de ensino. O mesmo princípio poderia ser aplicado a outras informações, como notas, horários de aulas, calendários etc.

Observação: Como cada instituição terá sua própria instância InterSystems IRIS de forma independente isso abre possibilidade para que as instituições implementem novas APIs e desenvolvam outros aplicativos, além dos padronizados, que seriam disponibilizados na plataforma como numa loja de APPs. Como podemos ver o InterSystems IRIS abre um leque de oportunidades, onde podemos usar diversas abordagens tecnológicas para transformar a educação do país.

Agora o Machine Learning

Nossa plataforma é construida em cima do InterSystems IRIS, como já sabemos, e a principal abordagem tecnológica usada em conjunto é o Machine Learning, por isso veremos a seguir como o Machine Learning muda tudo aqui e nos dar uma capacidade incrível de transformação da educação.

Para esta parte vamos precisar do IntegrateML e do autoML, dois recursos imprecionantes presentes no InterSystems IRIS, com eles vamos poder treinar e implantar modelos preditivos facilmente. Vamos agora verificar tipos de modelos que poderemos treinar que serão de estrema importância para dar a esta plataforma o poder de transformar a educação:

1. Modelo preditivo de desempenho acadêmico: Usando o autoML para criar rapidamente modelos preditivos precisos usando dados, como por exemplo notas de teste, vamos poder criar um modelo para prever o desempenho dos alunos em testes futuros. Ele pode ser usado para identificar os alunos que estão em risco de falhar em uma determinada disciplina e fornecer intervenções personalizadas para ajudá-los a melhorar.

2. Modelo preditivo de retenção de alunos: Usando dados históricos de desempenho acadêmico, frequência, participação e outros, vamos poder criar um modelo para prever a probabilidade de um aluno abandonar a escola ou faculdade. Ele pode ser usado para identificar os alunos que correm maior risco de desistir e fornecer intervenções personalizadas para ajudá-los.

3. Modelo preditivo de recomendação de conteúdo: Se lembra do que foi falado sobre atenção indívidual para acada aluno? Então, aqui podemos ter um modelo preditivo para a plataforma poder recomendar conteúdo específico com base nas preferências e desempenho acadêmico do aluno. Ele pode ser usado para oferecer conteúdo personalizado para cada aluno com base em suas necessidades individuais.

4. Modelo preditivo de detecção de plágio: Algo muito importante para uma platforma como esta, que abre portas para se aumentar ainda mais o uso de computadores na realização de muitas tarefas, como entrega de trabalhos, provas e testes. Com Este modelo vamos poder detectar a ocorrência de plágio em trabalhos escritos de alunos. Ele pode ser usado para identificar trabalhos que possam ter sido plagiados evitando assim que os alunos copiem conteúdo da internet.

5. Modelo preditivo de detecção de texto gerado por IA: Já que falamos de plágio, no ano de 2023 surgiu mais uma questão, o uso de IA para gerar texto para trabalhos acadêmicos, desta forma este modelo poderia identificar se um texto foi produzido por um ser humano ou por uma inteligência artificial. Isso seria útil em várias situações, como detecção de plágio, verificação de autenticidade de documentos, entre outros.

6. Modelo preditivo de desempenho em testes padronizados: No Brasil temos ums prova chamada ENEM, que é muito importante na vida profissional, pois abre portas para a entrada em universidades públicas e privadas. Aqui podemos criar um modelo para prever o desempenho dos alunos em provas como o ENEM, imagine esta plataforma cheia de dados, como notas, análises grámaticas de textos feitos pelos alunos, dados de testes práticos gerados pela plataforma, provas anteriores do ENEM e outros. Com o autoML usamos esses dados para criar um modelo preditivo que será capaz de prever o desempenho do aluno no ENEM e identificar os alunos que precisam de mais suporte para melhorar seu desempenho. Imagina só, provas como estas estariam integradas a plataforma também, para que as pessoas recebam seus resultados direto na plataforma, juntamente com uma análise de desempenho e de pontos a melhorar, até porque a ideia é que toda a vida acadêmica da pessoa seja usada como parâmetro para ingressar numa faculdade ou receber uma oportunidade de emprego.

7. Modelo preditivo de planejamento de carreira: Por falar em oportunidade de emprego, que tal um modelo que ajude no planejamento de carreira? Podemos usar dados de desempenho acadêmico e interesses pessoais para prever as carreiras mais adequadas para os alunos. Ele pode ser usado para oferecer sugestões personalizadas de carreira para os alunos e ajudá-los a planejar sua trajetória acadêmica e profissional.

8. Modelo preditivo de personalização de ensino: Para um modelo como este poderemos utilizar dados de desempenho acadêmico, interesses e habilidades dos alunos para personalizar o conteúdo de ensino e atividades para cada aluno individualmente. Assim esta plataforma poderá criar experiências de aprendizado mais eficazes e personalizadas para os alunos, melhorando assim seu desempenho e engajamento.

9. Modelo preditivo de avaliação de professores: Não podemos esquecer dos professores. Aqui temos um modelo que usa feedback dos alunos, dados de testes gerados pela plataforma para professores e etc, para avaliar a eficácia dos professores e identificar áreas de melhoria. Ele pode ser usado para fornecer informações úteis para os professores e administradores da escola e melhorar a qualidade do ensino.

10. Modelo preditivo de análise de dados de engajamento dos pais: Já falamos aqui sobre pais que delegam a educação de seus filhos, então, com este modelo, que pode utilizar dados de engajamento dos pais, como comparecimento a reuniões escolares e comunicação com professores e até de pequenos testes gerados pela plataforma para verificar o conhecimento que os pais tem sobre os filhos, como por exemplo: qual foi a nota de joãozinho na prova de matemática da semana passada? para prever o envolvimento dos pais na educação de seus filhos. Ele pode ser usado para identificar áreas de oportunidade para aumentar o engajamento dos pais e melhorar a qualidade da educação.

11. Modelo preditivo de análise de dados de IoT para segurança dos alunos: Aqui temos algo de extrema importância, um modelo que utiliza dados de dispositivos de segurança IoT, como câmeras e detectores de movimento, para prever possíveis ameaças à segurança dos alunos e prevenir incidentes. Por exemplo, o sistema pode detectar um comportamento suspeito em um indivíduo não identificado ou reconhecer padrões de tráfego para alertar a equipe de segurança sobre possíveis pontos de vulnerabilidade.

12. Modelo preditivo de monitoramento de indicadores educacionais: Bom, neste caso teriamos um modelo preditivo construido com base em dados de diversas fontes, como avaliações de desempenho, taxas de abandono escolar e outros, para monitorar os indicadores educacionais em diferentes áreas e níveis educacionais. Com base nessas previsões o MEC e as instituições poderiam tomar decisões informadas sobre políticas e investimentos educacionais.

Bom existem milhares de modelos que podemos criar e implantar para esta plataforma usando AutoML e IntegrateML, com os modelos apresentados aqui podemos ver que esta plataforma tem a capacidade de transformar totalmente a educação de paises inteiros. Podemos também ter outros modelos relacionados à gestão e acompanhamento, para servir ferramentas para diretores, professores e orgãos responsáveis que iram auxiliá los na tomada de decisão.

Conclusão

Enfim, assim solucionamos este caso de negócio, tão grande e importante para a sociedade, pudemos ver aqui que com o uso de InterSystems IRIS aliado principalmente ao Machine Learning podemos solucionar milhares de problemas no setor educacional, dando a capacidade de se servir soluções inovadoras que podem transformar completamente a educação do Brasil.

A plataforma de educação integrada, a educação de um jeito que você nunca viu. A educação transforma e uma plataforma como esta é capaz de transformar países interios, pois tem o poder de levar a educação a um nível nunca visto antes.